Frank Zappa might be a inspiration (tall order).

A technique I learned is chromatic planing, which uses coupling of one or more chord structures to a top melodic line.

For the classically trained musician the parallel motion might be a no go, but I personally like it a lot.

Opusmodus is perfectly suited to do this planing technique with gen-chord3.

Very brief snippet, which was arranged mostly with music generated from code below.

(setf melody-interval (interval-series '(1 5 7 5 1) '(1 2 7)))
(setf melody-pitch (ambitus '(c4 g5)
                            (interval-map 'd4 melody-interval)))
(setf melody-length (gen-tuplet 1 1 'n 'n 'w (mclength melody-pitch)))
(setf melody-omn (make-omn :pitch melody-pitch
                            :length melody-length))


(setf chord-interval '((-3 -7 -10 -12)   ;; m7
                       (-4 -7 -11 -12))) ;; maj7
(setf chord-omn (gen-chord3 melody-omn chord-interval :cycle t))
(setf rhodes-omn (closest-path chord-omn)) ; :type '(1 2 3 2)))
(setf bass-omn (omn-replace :articulation 'stacc
                            (pitch-transpose 0 (dechord chord-omn))))
(setf synth-omn (pitch-transpose 12 (dechord chord-omn :pitch 4)))
(setf marimba-omn (pitch-transpose 0 (dechord chord-omn :pitch 3)))

(ps 'gm
    :tempo 112
    :pg (list (length-weight rhodes-omn :weight '(2 1)))
    :bass (list (length-weight bass-omn :weight '(2 1)))
    :fl (list (length-weight synth-omn :weight '(2 1)))
    :ob (list (length-weight marimba-omn :weight '(2 1))))

(write-midi)

LuminousFracture2.pdf Luminous_Fractures_v2.csd

LuminousFractures2.opmo

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defun all-magic-square-lines (n)
  (let ((alist (magic-square n)))
      (append alist
            (loop for x from 0 to (1- (length (car alist)))
                          collect (loop for i in alist
                                        collect (nth x i)))

            (list (loop for i in alist
                  with cnt = 0
                  collect (nth cnt i)
                  do (incf cnt)))
            
            
            (list (loop for i in alist
                  with cnt = (1- (length (car alist)))
                  collect (nth cnt i)
              do (decf cnt))))))
    
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(all-magic-square-lines 3)
=> ((8 1 6) (3 5 7) (4 9 2) (8 3 4) (1 5 9) (6 7 2) (8 5 2) (6 5 4))

(all-magic-square-lines 4)
=> ((16 5 9 4) (2 11 7 14) (3 10 6 15) (13 8 12 1) (16 2 3 13) (5 11 10 8) (9 7 6 12) (4 14 15 1) (16 11 6 1) (4 7 10 13)) 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; test
(loop for i in (all-magic-square-rows 7)
        collect (sum i))
=> (175 175 175 175 175 175 175 175 175)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(all-magic-square-lines 3)

Here’s a short video demonstrating some experimentation with transmitting Opusmodus scores (using MusicXml2ly) to a pre-defined template in Lilypond.

• To accomplish this, I’ve created a String trio template in Lilypond and implemented a highly intricate function with the invaluable assistance of OpusmodusGPT. Opusmodus exports the Opusmodus XML file to Lilypond using MusicXml2ly, and it automatically extracts the content of this file and pastes it into the appropriate variables within the template. Subsequently, the file is saved on disk, and Lilypond is invoked to compile it. Finally, the resulting PDF is displayed using the preview function.

Phase Space 247 conceives music as a dynamic system evolving within a space of possibilities. Inspired by the notion of phase space in physics and mathematics, each musical parameter — pitch, rhythm, density, dynamics, instrumentation — is treated as a dimension of a multidimensional field, within which the sonic material traces its trajectories. The piece is driven by an algorithmic process shaped by global tendencies (attractors) and local variations. A shared underlying force field influences all voices, ensuring perceptual coherence, while each line retains expressive autonomy through fluctuations, silences, ornaments, and internal displacements. Rather than following a fixed formal plan, the work unfolds through an unstable balance between determinacy and indeterminacy, memory and noise, repetition and transformation. Certain sections may exhibit palindromic structures or internal echoes, as if the system were recalling its own previous states. Tempo changes, density distributions, and the morphology of instrumental textures emerge directly from the generative process itself, making the algorithm not merely a production tool, but a genuine formal compositional model. Phase Space 247 invites the listener to follow the evolution of a continuously transforming sonic organism, where form is never imposed, but constantly attracted.

Stéphane Boussuge - Composer

Here is a small graphical model showing four generations. The start and end points remain the same, while new random points are added in between with each generation.

The Code & Examples

(defun pick (a b &key (span 5))
  (let ((rnd1 (car (rnd-number 1 (+ a span) (- a span))))
        (rnd2  (car (rnd-number 1 (+ b span) (- b span))))
        (n))
    (progn
      (setf n (car (rnd-number 1 rnd1 rnd2)))     
      (if (or (= n a) (= n b))
        (+ (rnd-pick '(1 -1)) n)
        n))))


(defun gen-brownian-bridge (n startend &key (all-gen nil) (output 'integer) (span 5))
  (let ((seq)
        (liste startend))
    (progn
      (setf seq (append (list startend)
                        (loop repeat n
                              do (setf liste (filter-repeat 1 (loop repeat (1- (length liste))
                                                                    for cnt = 0 then (incf cnt)
                                                                    append (append (list (nth cnt liste) 
                                                                                         (pick (nth cnt liste) 
                                                                                               (nth (1+ cnt) liste) 
                                                                                               :span span)
                                                                                         (nth (1+ cnt) liste))))))
                              collect liste)))
      (setf seq (if (equal all-gen t)
                    seq
                  (car (last seq))))
      (if (equal output 'pitch)
          (integer-to-pitch seq)
        seq))))


(defun remove-duplicates-keep-edges (lst)
  "Entfernt innere Duplikate aus LST, behält aber den ersten und letzten Wert unabhängig von Wiederholungen."
  (let* ((first (first lst))
         (last (car (last lst)))
         (len (length lst))
         (result '())
         (seen '())
         (index 0))
    (dolist (el lst (reverse result))
      (cond
        ;; Ersten Wert immer behalten
        ((= index 0)
         (push el result)
         (push el seen))
        ;; Letzten Wert immer behalten
        ((= index (1- len))
         (push el result))
        ;; Innere Duplikate von first oder last überspringen
        ((or (and (eq el first) (/= index 0))
             (and (eq el last) (/= index (1- len))))
         ;; überspringen
         nil)
        ;; Andere Duplikate vermeiden
        ((not (member el seen))
         (push el result)
         (push el seen)))
      (setf index (1+ index)))))

;(remove-duplicates-keep-edges '(a b c a d e b c))

(defun reset-pitch-sequence (pitch-sequence pitch &key (type 'low))
  (let ((pitch1 (cond  ((equal type 'low)
                        (car (get-ambitus pitch-sequence :type :pitch)))
                       ((equal type 'high)
                        (cadr (get-ambitus pitch-sequence :type :pitch)))
                       ((equal type 'center) 
                        (center-position-in-list (sort-asc pitch-sequence) :get-value t)))))

    (if (not (omn-formp pitch-sequence))
      (pitch-transpose (car (pitch-to-interval (list (if (chordp pitch1)
                                                       (car (pitch-melodize pitch1))
                                                       (append pitch1))
                                                     pitch))) pitch-sequence)

      (omn-component-replace pitch-sequence
                             (pitch-transpose (car (pitch-to-interval (list (if (chordp pitch1)
                                                                              (car (pitch-melodize pitch1))
                                                     (append pitch1))
                                                                            pitch))) (omn :pitch pitch-sequence))))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;; only the main function, to see how it works
;;; 6 generations, start with 3 end with 2, span = max inteval/seps
;;; 

(list-plot
 (flatten (gen-brownian-bridge 6 '(3 2) :span 4  :all-gen t))
 :join-points nil :style :fill)


(gen-brownian-bridge 4 '(3 2) :span 3  :all-gen t)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


;;; example with 6 generations
;;; every generation in an new bar to show how ith works

(omn-list-plot
(progn
  (setf seq (reset-integer-sequence (gen-brownian-bridge 6 '(3 2) :span 4  :all-gen t)))                               
  (setf pitchfield (make-scale 'c4 (find-max (flatten seq)) :alt '(1 1 2 4 7 4 2)))
  (setf pitch (position-filter seq pitchfield))

  (setf rhy 1/16)
  (setf lengths (loop for i in pitch
                        collect (length-rational-quantize (gen-length (gen-repeat (length i) 1) rhy) :round '10/4)))
  (make-omn
   :pitch pitch
   :length lengths))
:join-points nil :style :fill)


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


;;; ALL DUPLCIATIONS INSIDE one PHRASE are removed!!!

;;; example with 6 generations
;;; every generation in an new bar to show how ith works
;;;


(omn-list-plot
(progn
  (setf seq (reset-integer-sequence (loop for i in (gen-brownian-bridge 6 '(3 2) :span 4  :all-gen t)
                                          collect (remove-duplicates-keep-edges i))))

  (setf pitchfield (make-scale 'c4 (find-max (flatten seq)) :alt '(1 1 2 4 7 4 2)))
  (setf pitch (position-filter seq pitchfield))

  (setf rhy 1/16)
  (setf lengths (loop for i in pitch
                        collect (length-rational-quantize (gen-length (gen-repeat (length i) 1) rhy) :round '6/4)))
  (make-omn
   :pitch pitch
   :length lengths))

:join-points nil :style :fill)

      

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Followup on post: https://opusmodus.com/forums/topic/3989-om-lydian-chromatic-concept-of-tonal-organization-george-russell/

"Enthous" is a small piece, which tries to use techniques of LCCOTO in 2 parts form each using alternations of 2 parent-scales.

Opusmodus is very well equipped for LCCOTO 😀.

Comments

• Function find-chord-for-parent-scale is implemented here: https://opusmodus.com/forums/topic/3998-take-3-lydian-chromatic-concept-of-tonal-organization-george-russell/

• Function write-midi is implemented here: https://opusmodus.com/forums/topic/4024-command-to-include-in-def-score-or-at-the-end-of-code-to-automaticcaly-store-the-evaluation-as-indexed-midi-file-to-a-predefine-folder/#findComment-13925

• I am making heavy use of arrows package to pipe operations (especially here arrows:-<>), enhancing readability from top to bottom. See my request to enable this in OM w/o namespace-qualifier on this here.

Part A:

;; Enthous - A modal piece
;; Part A
;;
;; C. Scherer, 2025/26
;;


(asdf:load-system :arrows)

(progn 

;; Part A - Parent scale
(setf parent-scale-a '(eb lydian))
(setf parent-scale-b '(c lydian))
(setf scale-a (second parent-scale-a))
(setf scale-b (second parent-scale-b))
(setf root-a (first (expand-tonality parent-scale-a)))
(setf root-b (first (expand-tonality parent-scale-b)))
(setf scale-tonality (tonality-series (list scale-a scale-b) 
                                        :root (list root-a root-b) :map 'octave :variant 'p))

;; Select Chords in this parent scale
(create-chord quartal-chord-4a '(0 5 10 14))
(create-chord quartal-chord-4b '(0 5 10 15))
(setf chords 
      (arrows:-<>
       (list parent-scale-a )
        (find-chord-for-parent-scale '((quartal-chord-4a quartal-chord-4b)))
        (flatten-sublist)
        (flatten-sublist)
        (expand-chord)
        (mclist)
        ))

;; Chord-Track
(setf chords-omn
      (arrows:-<>
       (make-omn :length (rnd-sample 8 (rhythm-series 1 5 8/4 :length '(h. q. e) :seed 40))
                 :pitch (rnd-sample 8 chords :seed 42)
                 :velocity (vector-to-velocity 'pppp 'f
                                               (gen-ar-time-series 64 '(0.8) 0.2 :seed 42))
                )
       (omn-to-time-signature <> '(4 4))
       (drop-voicing <> :type (rnd-sample 5 '(2 3)) :leading 't)
       (melodize-to-length 's 'e <>)
       (pitch-transpose -24 <>)
       (pitch-ornament)
       (tonality-map scale-tonality <> :time '(ww ww))
       (dictum '(:bar 16 :substitute '(w c3 mp)) <> )
       (velocity-to-dynamic)
       ))
(setf total-span-a (get-span chords-omn :sum t))
 

;; Melodic line 
(setf melo-mat
      (arrows:-<>
       (gen-ar-time-series 128 '(0.7) 0.5 )
       (vector-to-pitch '(eb4 f6) <>)
       (filter-repeat 1 <>)
       ))
(pitch-list-plot (flatten melo-mat))

(setf length-mat (euclidean-rhythm '(4 4) 1 4 1/4 :type 3))
(setf melody
      (arrows:-<>
       (make-omn :pitch melo-mat
                 :length (length-span total-span-a length-mat)
                 :velocity (vector-to-velocity 'pp 'fff 
                                               (gen-ar-time-series 64 '(0.7) 0.5 :seed 23))
                 :swallow nil
                 )
       (omn-to-time-signature <> '(4 4))
       ;(bind-to-interval '(-3 -3 -3 -3) <>)
       (passing-intervals '((2 (1 1)(2) )(-2 (-1 -1))
                            (3 (1 1 1))(-3 (-1 -1 -1))
                            (4 (2 2)(1 1 1 1))(-4 (-2 -2)(-1 -1 -1 -1))
                            (5 (1 1 1 1 1))(-5 (-1 -1 -1 -1 -1))
                            (6 (2 1 2 1))(-6 (-2 -1 -2 -1))
                            (7 (2 1 1 1 1))(-6 (-2 -1 -1 -1 -1))
                            ) <>)
       (quantize <> '(1 2 3 4 5))
       (length-augmentation '(2) <> :section '(0))
       (tonality-map scale-tonality <> :time '(ww ww))
       (flatten)
       (closest-path :ambitus '(eb4 f6))
       (filter-anacrusis)
       (omn-to-time-signature <> '(4 4))
       (fit-to-span total-span-a <>)
       (dictum '(:bar 16 :substitute '(w c4 mf)) <> )
       (velocity-to-dynamic)
       ))

;; Bass Line
(setf bass
      (arrows:-<>
       (make-omn :pitch (rnd-sample total-span-a '(c2 c2 c2 c2  c3 g2 b1))
                 :length (gen-repeat total-span-a (list (append
                                                   (fit-to-span 1 (pcs-rhythm '6-7 
                                                                              :rotate 0
                                                                              :value 'e))
                                                   (fit-to-span 1 (pcs-rhythm '6-7 
                                                                              :rotate -4
                                                                              :value 'e)))))
                 :velocity (vector-to-velocity 'p 'ff
                                               (gen-ar-time-series 128 '(0.8) 0.2 :seed 42))
                 :articulation (gen-loop 16 (vector-map '(stacc marc def leg)
                                           (gen-ar-time-series 8 '(0.8) 0.2)))
                 :swallow nil
                 )
       (omn-to-time-signature <> '(4 4))
       (tonality-map scale-tonality <> :time '(ww ww))
       (omn-to-time-signature <> '(4 4))
       (fit-to-span total-span-a <>)
       (quantize <> '(1 2 4))
       (dictum '(:bar 16 :do '(c2)) <> )
       (velocity-to-dynamic)
       ))

;; Preview
(ps 'gm
    :tempo 77
    :time-signature '(4 4)
    :p (list melody chords-omn)
    :bass (list bass)
)



(write-midi)

)

Part B:

;; Enthous - A modal piece
;; Part B
;;
;; C. Scherer, 2025/26
;;


(asdf:load-system :arrows)

(progn 

;; Part A - Parent scale
(setf parent-scale-a '(a lydian-augmented))
(setf parent-scale-b '(c lydian))
(setf scale-a (second parent-scale-a))
(setf scale-b (second parent-scale-b))
(setf root-a (first (expand-tonality parent-scale-a)))
(setf root-b (first (expand-tonality parent-scale-b)))
(setf scale-tonality (tonality-series (list scale-a scale-b) 
                                        :root (list root-a root-b) :map 'octave :variant 'p))

;; Select Chords in this parent scale
(create-chord quartal-chord-4a '(0 5 10 14))
(create-chord quartal-chord-4b '(0 5 10 15))
(setf chords 
      (arrows:-<>
       (list parent-scale-a )
        (find-chord-for-parent-scale '((quartal-chord-4a quartal-chord-4b)))
        (flatten-sublist)
        (flatten-sublist)
        (expand-chord)
        (mclist)
        ))

;; Chord-Track
(setf chords-omn
      (arrows:-<>
       (make-omn :length (rnd-sample 16 (rhythm-series 1 4 4/4 :length '(h. q. e) :seed 43))
                 :pitch (rnd-sample 8 chords :seed 42)
                 :velocity (vector-to-velocity 'ppp 'mp
                                               (gen-ar-time-series 64 '(0.8) 0.2 :seed 43))
                )
       (omn-to-time-signature <> '(4 4))
       (drop-voicing <> :type (rnd-sample 5 '(2 3)) :leading 't)
       (melodize-to-length 's 'e <>)
       (pitch-transpose -24 <>)
       (pitch-ornament)
       (tonality-map scale-tonality <> :time '(ww ww))
       (dictum '(:bar 16 :substitute '(w c3 mp)) <> )
       (velocity-to-dynamic)
       ))
(setf total-span-a (get-span chords-omn :sum t))
 

;; Melodic line 
(setf melo-mat
      (arrows:-<>
       (gen-ar-time-series 128 '(0.9) 0.1 )
       (vector-to-pitch '(eb4 f6) <>)
       (filter-repeat 1 <>)
       (reverse)
       ))
(pitch-list-plot (flatten melo-mat))

(setf length-mat '(-e e s s s s -e q -q))
(setf melody
      (arrows:-<>
       (make-omn :pitch melo-mat
                 :length (length-span total-span-a length-mat)
                 :velocity (vector-to-velocity 'pp 'fff 
                                               (gen-ar-time-series 64 '(0.7) 0.5 :seed 23))
                 :swallow nil
                 )
       (omn-to-time-signature <> '(4 4))
       (bind-to-interval '(-2 -2 -2 -2) <>)
       ;(passing-intervals '((2 (1 1)(2) )(-2 (-1 -1))
       ;                     (3 (1 1 1))(-3 (-1 -1 -1))
       ;                     (4 (2 2)(1 1 1 1))(-4 (-2 -2)(-1 -1 -1 -1))
       ;                     (5 (1 1 1 1 1))(-5 (-1 -1 -1 -1 -1))
       ;                     (6 (2 1 2 1))(-6 (-2 -1 -2 -1))
       ;                     (7 (2 1 1 1 1))(-6 (-2 -1 -1 -1 -1))
       ;                     ) <>)
       (quantize <> '(1 2 3 4))
       (length-augmentation '(2) <> :section '(0))
       (length-augmentation '(2) <> :section '(7))
       (tonality-map scale-tonality <> :time '(ww ww))
       (flatten)
       (closest-path :ambitus '(d4 c5))
       ;(filter-anacrusis)
       (omn-to-time-signature <> '(4 4))
       (fit-to-span total-span-a <>)
       (dictum '(:bar 16 :substitute '(w c4 mf)) <> )
       (velocity-to-dynamic)
       ))

;; Bass Line
(setf bass
      (arrows:-<>
       (make-omn :pitch (rnd-sample total-span-a '(c2 c2 c2 c2 g1))
                 :length (gen-repeat total-span-a (list (append
                                                   (fit-to-span 1 (pcs-rhythm '7-7 
                                                                              :rotate 0
                                                                              :value 'e))
                                                   (fit-to-span 1 (pcs-rhythm '7-7 
                                                                              :rotate -4
                                                                              :value 'e)))))
                 :velocity (vector-to-velocity 'p 'ff
                                               (gen-ar-time-series 128 '(0.8) 0.2 :seed 42))
                 :articulation (gen-loop 16 (vector-map '(stacc marc def leg)
                                           (gen-ar-time-series 8 '(0.8) 0.2)))
                 :swallow nil
                 )
       (omn-to-time-signature <> '(4 4))
       (tonality-map scale-tonality <> :time '(ww ww))
       (omn-to-time-signature <> '(4 4))
       (fit-to-span total-span-a <>)
       (quantize <> '(1 2 4))
       (dictum '(:bar 16 :substitute '(w c2 mf)) <> )
       (velocity-to-dynamic)
       ))

;; Preview
(ps 'gm
    :tempo 77
    :time-signature '(4 4)
    :p (list melody chords-omn)
    :bass (list bass)
)



(write-midi)

)

With great joy, I´d like to share with you an important international prize I received as composer in 28th november. It´s the IBERMÚSICAS prize for Symphonic Band 2025. It was very competitive and I´m honored to represent Brazil in this contest.

I´m posting this here because Opusmodus became since 2017 a very important tool in my compositional process, although I do not use it from beginning to end, i.e., there are many things I do manually. Nevertheless, it plays a crucial role in my workflow and I´d like to thanks the team for this.

All the best and happy 2026 !

Here are the selected compositions:

https://seleccionados2025.ibermusicas.org/

And the information of the selection:

https://www.ibermusicas.org/index.php/um-juri-constituido-por-maestras-e-maestros-de-renome-levou-a-cabo-o-processo-de-qualificacao-e-selecao-das-obras-vencedoras-do-premio-ibermusicas-para-a-composicao-de-obra-para-banda-sinfonica-20/

Translation

A jury composed of renowned conductors carried out the qualification and selection process for the winning works of the “Ibermúsicas Prize for the Composition of a Work for Symphonic Band” 2025.

Encouraging musical creation, Ibermúsicas has launched a new edition of its competitions for the creation of academic works, this time specifically focused on the creation of new works for symphonic bands, to be premiered by top-tier ensembles from Colombia, Costa Rica, Cuba, Mexico, and Venezuela.

In this edition, composers were invited to draw inspiration from the Ibero-American soundscape, as a diverse and colorful space, varied and contrasting, which, despite its differences, weaves threads, like the symphonic wind bands that traverse our countries and blend with their different cultures, to find very particular sonorities that make them unique in each country or region.

With the aim of promoting mutual understanding between the peoples and the specific subsector of wind bands among our countries, composers were encouraged to explore this sonic universe through the repertoires, genres, and soundings of bands from different countries, schools, and their reference composers, among many other possibilities that unite the countries that are part of Ibero-American cooperation.

The award includes, in addition to financial recognition for each creator, the premiere of the winning works performed by the Valle Departmental Symphonic Band of Colombia, one of the seven bands of the General Directorate of Bands of Costa Rica, the National Concert Band of Cuba, the Symphonic Band of the Faculty of Music of UNAM in Mexico, and the Caracas Marching Band of Venezuela.

The jury, composed of Andrés Porras Alfaro from Costa Rica, David Leonardo Guarin Ortiz from Colombia, Marcia Quesada from Cuba, Luis Manuel Sánchez from Mexico, and Pedro Mauricio Gonzalez from Venezuela, worked intensively on selecting the winning works from among the 62 submitted to the competition under pseudonyms.

With pride and joy, the Ibermúsicas Program invites you to discover the names of the winning male and female composers of this competition here.

https://seleccionados2025.ibermusicas.org/

Here's another a bit more involved attempt using LCCOTO for my naive take of a fusion piece.

The chord track for 2 parts is given, melodies use the LCCOTO parent scale for chords.

One can exchange by other more outgoing scales.

Audio example are for normal, most ingoing lydian scale.

Code for the function find-parent-scale-for-chord is this post

3 picked audio manifestations with different start seeds.

Seed: 78641

Seed: 34987

Seed: 10461

Here's the code. Appreciate any improvement suggestions.

;; ---------------------------------------------------------
;; 
;; LCCOTO Chordtrack derived tonaloity-series
;;
;; Variations Part A, B
;;
;; Cliff Scherer, 2025
;;
;; ---------------------------------------------------------

(progn

(setf seed (rnd-pick (gen-integer-seq '((1 100000)))))
(init-seed seed)

(defun prepare-fusion (&key total-span 
                            chord-track
                            parent-scale-candidates
                            melody-number-of-notes
                            melody-augmentation-factor
                            melody-tuplet) 
  
  "Prepare parts of a fusion piece"

   ;; Chords, Harmony
   (setf chord-track (length-span total-span chord-track))
   (setf harmonic-rhythm (omn :length (filter-tie chord-track)))
   
   ;; Bass
   (setf bass-rhythm-cell (length-span '(1) (pcs-rhythm '3-11 :points 6 
                                                     :rotate (rnd-pick '(0 5)) 
                                                     :legato t)))
   (setf bass-pitch-cell (rnd-pick '((c2 g2 b2)(c2 g2 d2))))
   (setf bass-mat (make-omn :pitch (pitch-transpose -0 bass-pitch-cell)
                         :length (length-span total-span bass-rhythm-cell)
                         :velocity '((0.6 0.51 0.5 0.55))
                         :articulation '(leg stacc stacc stacc )))

   ;; Melody
   (setf pattern (rhythm-series 2 melody-number-of-notes 4/4))
   (setf pattern-length (length-span total-span (quantize (length-augmentation 1 pattern)
                                                          melody-tuplet)))
   (setf pattern-pitch (bind-to-interval 
                        '(7 -7) 
                        (gen-divide 5 
                                    (vector-to-pitch '(c4 g5) 
                                                     (gen-accumulate (rndn 128 
                                                                           -1.0 1.0) :decf t)))))
                        (setf melody-mat (make-omn :pitch pattern-pitch                  
                              :length pattern-length
                              :velocity (rnd-sample 5 '((f mf) (f mp) (mf < p > pp >)))))
   

   ;; Drums
   (setf bd (gen-loop 2 (polygon-rhythm 5 8 0 :value 'e  :pitch 'c2 :velocity '(f p = = = =))))
   (setf hh (gen-loop 2 (polygon-rhythm 28 32 2 :value 's :pitch 'fs2 :velocity '(f ff mf p p f))))
   (setf ho (gen-loop 2 (polygon-rhythm 3 64 4 :value 's :pitch 'as2 :velocity '(p p))))
   (setf to (polygon-rhythm 3 8 4 :value 'e :pitch 'g2 :velocity '(p mp)))
   (setf bd-omn (assemble-seq (length-span (- total-span 1) (first bd)) 
                              (length-span 1 (second bd))))
   (setf hh-omn (assemble-seq (length-span (- total-span 1) (first hh)) 
                              (length-span 1 (second hh))))
   (setf ho-omn (assemble-seq (length-span (- total-span 1) (first ho)) 
                              (length-span 1 (second ho))))
   (setf to-omn (assemble-seq (length-span (- total-span 1) '(-e))
                              (length-span 1 to)))
                                           
   (setf drums-omn (merge-voices bd-omn hh-omn ho-omn to-omn))

   ;; Sax play same as melody but with alteration
   (setf sax-mat (pitch-transpose -36 (ambitus-field '(0 15) (pitch-invert melody-mat))))


   ;;; Bring lines to tonality

   ;; For Melody use LCCOTO parent scale for melody
   (setf chord-symbols  (omn :pitch (filter-tie chord-track)))
   (setf parent-scales (mapcar 'rnd-pick 
                            (find-parent-scale-for-chord (mclist chord-symbols) 
                                                         :scales parent-scale-candidates)))
   (setf parent-scales-root (mapcar 'find-root (mclist(expand-chord parent-scales))))
   (setf parent-scales-mode (mapcar 'second parent-scales))
   (setf parent-tonality-series (tonality-series parent-scales-mode 
                                              :root parent-scales-root 
                                              :map 'octave :ambitus '(c4 g5) :variant 'p))
   (setf melody-omn (filter-tie (tonality-map parent-tonality-series melody-mat 
                                  :time harmonic-rhythm)))

   (setf sax-omn (length-weight
                  (length-legato (filter-tie (tonality-map parent-tonality-series sax-mat 
                                                           :time harmonic-rhythm)))
                  :weight '(5 1)))

   ;; For Bass use chord
   (setf chord-pitches (chord-interval-remove '(10 11) chord-symbols))
   (setf chord-tonality-series (tonality-series chord-pitches :map 'octave))
   (setf bass-omn (tonality-map chord-tonality-series bass-mat
                             :time harmonic-rhythm))

   ;; For Chords some variation
   (setf chord-omn (pitch-transpose -12 (closest-path (drop-voicing chord-track :type '(1)))))
   (setf chord-omn (omn-replace :velocity (rnd-sample 2 '(mf mp)) chord-omn))

   
   ;; Prepare voices
   (setf v1 (omn-to-time-signature melody-omn '(4 4))
         v2 (omn-to-time-signature chord-omn '(4 4))
         v3 (omn-to-time-signature bass-omn '(4 4))
         v4 (omn-to-time-signature sax-omn '(4 4))
         v5 (omn-to-time-signature drums-omn '(4 4)))

   ;; Timeline
   (setf on-off (gen-binary-series 24 '( 2 3) '(3) :rotate -4))
   (do-timeline2 '(v1 v4) on-off '(gen-pause x) :time '(wh) :loop t)

   (def-score fusion
       (:key-signature 'chromatic
        :time-signature '(4 4)
        :tempo '(80)
        :layout (list
                 (bracket-group
                  (grand-layout 'rhand :name "Rhodes" :abbr "Rhodes")
                  (grand-layout 'lhand :name "Piano" :abbr "Piano"))
                 (tenor-sax-layout 'sax :name "Sax" :abbr "Sax")                 
                 (bass-layout 'bass :name "Bass" :abbr "Bass")
                 (drum-kit-layout 'drums :name "Drums" :abbr "Drums")))
     
     (rhand
      :port "Bus 1"
      :omn v1
      :sound 'gm 
      :program 'acoustic-grand-piano)
     (lhand
      :omn v2
      :port "Bus 2")
     (bass
      :omn v3
      :port "Bus 3")
     (sax
      :omn v4
      :port "Bus 4")
     (drums
      :omn v5
      :port "Bus 5")
     )
   )


;;; Use the function

(setf lydian-chromatic-scale (make-scale 'c1 12 :alt '(7 7 7 7 7 7 2 7 7 7 8)))
(create-tonality lydian-chromatic 'lydian-chromatic-scale)
(create-tonality lydian-chromatic-scale-6 (subseq lydian-chromatic-scale 1 6))
(create-tonality lydian-chromatic-scale-7-mod1 (subseq lydian-chromatic-scale 1 8))
(create-tonality lydian-chromatic-scale-7-mod2 (subseq lydian-chromatic-scale 2 9))



;; Create score
(setf fusion-a1 (prepare-fusion :total-span 8
                               :chord-track '((e. (f m7))(e. (f m7))(he (gs m7)))
                               :parent-scale-candidates '(lydian)
                               :melody-number-of-notes 2
                               :melody-augmentation-factor 3
                               :melody-tuplet '(1 2 4)))
(setf fusion-a2 (prepare-fusion :total-span 8
                               :chord-track '((e. (f m7))(e. (f m7))(he (gs m7)))
                               :parent-scale-candidates '(lydian)
                               :melody-number-of-notes 3
                               :melody-augmentation-factor 2
                               :melody-tuplet '(1 2 4)))
(setf fusion-b1 (prepare-fusion :total-span 8
                               :chord-track '((q. (e maj7))(e. (e 6))(qes (g 6)))
                                :parent-scale-candidates '(lydian)
                                :melody-number-of-notes 8
                                :melody-augmentation-factor 1
                                :melody-tuplet '(1 2 4)))
(setf fusion-b2 (prepare-fusion :total-span 8
                                :chord-track '((q. (e maj7))(e. (e 6))(qes (g 6)))
                                :parent-scale-candidates '(lydian)
                                :melody-number-of-notes 8
                                :melody-augmentation-factor 1
                                :melody-tuplet '(3)))

;; Arrange and Record MIDI
(setf start-1 (rnd-sample 7 '(1 2 3 4 5 6)))
(setf end-1 (x+b start-1 0))
(setf start-2 (rnd-sample 7 '(1 2 3 4 5)))
(setf end-2 (x+b start-2 1))


(compile-score 
 `(
   ;; 8 basr with a1
   (,(eval fusion-a1) :start 1 :end 1)
   (,(eval fusion-a1) :start 1 :end 1)
   (,(eval fusion-a1) :start ,(nth 0 start-2) :end ,(nth 0 end-2))
   (,(eval fusion-a1) :start ,(nth 1 start-2) :end ,(nth 1 end-2))
   (,(eval fusion-a1) :start ,(nth 1 start-1) :end ,(nth 1 end-1))
   (,(eval fusion-a1) :start 8 :end 8)
   ;; 8 bars with a2
   (,(eval fusion-a2) :start 1 :end 1)
   (,(eval fusion-a2) :start 1 :end 1)
   (,(eval fusion-a2) :start ,(nth 0 start-2) :end ,(nth 0 end-2))
   (,(eval fusion-a2) :start ,(nth 1 start-2) :end ,(nth 1 end-2))
   (,(eval fusion-a2) :start ,(nth 2 start-1) :end ,(nth 2 end-1))
   (,(eval fusion-a2) :start 8 :end 8)
   ;; 8 bars with b1
   (,(eval fusion-b1) :start 1 :end 1)
   ;;(,(eval fusion-b1) :start 1 :end 1)
   (,(eval fusion-b1) :start ,(nth 3 start-1) :end ,(nth 3 end-1))
   (,(eval fusion-b1) :start ,(nth 0 start-2) :end ,(nth 0 end-2))
   (,(eval fusion-b1) :start ,(nth 1 start-2) :end ,(nth 1 end-2))
   (,(eval fusion-b1) :start ,(nth 4 start-1) :end ,(nth 4 end-1))
   (,(eval fusion-b1) :start 8 :end 8)
   ;; 8 bars with b2
   (,(eval fusion-b2) :start 1 :end 1)
   (,(eval fusion-b1) :start ,(nth 5 start-1) :end ,(nth 5 end-1))
   (,(eval fusion-b2) :start ,(nth 0 start-2) :end ,(nth 0 end-2))
   (,(eval fusion-b2) :start ,(nth 1 start-2) :end ,(nth 1 end-2))
   (,(eval fusion-b2) :start ,(nth 6 start-1) :end ,(nth 6 end-1))
   (,(eval fusion-b2) :start 8 :end 8) 
   ;;
   (,(eval fusion-a1) :start 1 :end 1)
   (,(eval fusion-a1) :start 1 :end 1)
)
 :instrument t
 :output :midi
 :file (workspace-file "v.mid")
 :if-exists :new-index
 )

seed

)
  

Here's another 16bars short attempt to play with different level of in- and outgoing melodies according to LCCOTO..

Code for the function find-chord-for-parent-scale is this post.

Would be great to have a scale like lydian-chromatic (c1 g1 d2 a2 e3 b3 fs4 gs4 eb5 bb5 f6 cs7) properly built into OM (respecting the order of pitches, which is important for LCCOTO).

Maybe with a reference to Russell as this seems to be a tradition in OM (Modes.opmo).

The OM built-in scale chromatic-lydian with similar name seems to be 7-pitch scale (c4 cs4 e4 f4 fs4 a4 b4).

(setf seed (rnd-pick (gen-integer-seq '((1 100000)))))
(init-seed seed)


;;; Idea --------------
;;;
;;; Cliff Scherer, 2025
;;;
;;; Melodic pitch material from two parent scales with different levels of ingoing/outgoing
;;; Chords symbol material in one scale
;;; Bass pitch for chords
;;; All materials are organized in lists aligned to the same size
;;; Later we may pick list elements using one random master index
;;;


;;; Scales

;; Define LCCOTO scale ---

(setf lydian-chromatic-scale (make-scale 'c1 12 :alt '(7 7 7 7 7 7 2 7 7 7 8)))
(create-tonality lydian-chromatic 'lydian-chromatic-scale)

;; Set 2 parent scale tonics ---

(setf 
 c-lydian-chromatic-scale (expand-tonality '(c lydian-chromatic))
 eb-lydian-chromatic-scale (expand-tonality '(eb lydian-chromatic)))



;;; Melody

;; Melody pitch material with different consonance/dissonance 

(setf 
 c-lydian-chromatic-1 (ambitus '(c4 c5) (gen-surround c-lydian-chromatic-scale :start 0 :size 5))
 eb-lydian-chromatic-1 (ambitus '(eb4 eb6) (gen-surround eb-lydian-chromatic-scale :start 0 :size 5))
 c-lydian-chromatic-2 (ambitus '(c4 c6) (gen-surround c-lydian-chromatic-scale :start 0 :size 7))
 eb-lydian-chromatic-2 (ambitus '(eb4 eb6) (gen-surround eb-lydian-chromatic-scale :start 0 :size 6))
 c-lydian-chromatic-3 (ambitus '(c5 c6) (gen-surround c-lydian-chromatic-scale :start 2 :size 8))
 eb-lydian-chromatic-3 (ambitus '(c5 c6) (gen-surround eb-lydian-chromatic-scale :start 2 :size 5)))

(setf
 melo-mat-size 2
 melo-mat-pitch-1 (rnd-sample melo-mat-size (combination 4 c-lydian-chromatic-1))
 melo-mat-pitch-2 (rnd-sample melo-mat-size (combination 4 c-lydian-chromatic-2))
 melo-mat-pitch-3 (rnd-sample melo-mat-size (combination 4 c-lydian-chromatic-3))
 melo-mat-pitch-4 (rnd-sample melo-mat-size (combination 4 eb-lydian-chromatic-1))
 melo-mat-pitch-5 (rnd-sample melo-mat-size (combination 4 eb-lydian-chromatic-2))
 melo-mat-pitch-6 (rnd-sample melo-mat-size (combination 4 eb-lydian-chromatic-3))
 ;; main result
 melo-mat-pitch (flatten-sublist (list melo-mat-pitch-1 melo-mat-pitch-1 
                                       melo-mat-pitch-2 melo-mat-pitch-2 
                                       melo-mat-pitch-3
                                       melo-mat-pitch-4 melo-mat-pitch-4
                                       melo-mat-pitch-5  
                                       melo-mat-pitch-6))
)

;; Voice-variant material for melody
(setf 
 melo-voice-variant-variant '(a d ad d)
 melo-voice-variant-tuplet '(1 1 1 1))

;; Melody velocity material
(setf melo-mat-velocity '((0.1)(0.2)(0.3)(0.4)(0.45)))

;; Melody initial length material
(setf melo-mat-length-cell-1 (pcs-rhythm '7-35 :rotate '(10) :legato t))
(setf melo-mat-length-cell-2 (pcs-rhythm '7-35 :rotate '(11) :legato t))

(setf melo-mat-length (list (fit-to-span '4/4 melo-mat-length-cell-1)
                            (fit-to-span '4/4 (length-augmentation 2 melo-mat-length-cell-1))
                            (fit-to-span '4/4 (length-augmentation 4 melo-mat-length-cell-1))
                            (fit-to-span '4/4 melo-mat-length-cell-2)
                            (fit-to-span '4/4 (length-augmentation 2 melo-mat-length-cell-2))
                            (fit-to-span '4/4 (length-augmentation 4 melo-mat-length-cell-2))))
                            


;;; Chords

;; Chord pitch material 

(setf 
 chord-quality '((m7/add2)(maj7/add2)(7/sus2))
 chords-found-in-scale (find-chord-for-parent-scale chord-scale chord-quality)
 chord-mat-size 2
 ;; main result
 chord-mat-symbol (combination chord-mat-size 
                               (flatten-sublist (flatten-sublist chords-found-in-scale))))

;; Chord velocity material
(setf chord-mat-velocity '((0.1)(0.2)(0.3)(0.35)))

;; Chord length material
(setf chord-mat-length '((q -q q -q)(-q q -q q)(e -q. q -q)(q. -e q. -e)))


;;; Bass

;; Bass pitch material 
(setf 
 chord-mat-root (find-root (flatten-sublist chord-mat))
 bass-mat-pitch (pitch-transpose -24 (gen-divide chord-mat-size chord-mat-root)))

;; Bass velocity material
(setf bass-mat-velocity '((0.45)(0.5)(0.55)(0.6)(0.65)))

;; Bass length material
(setf bass-mat-length '((h h)(q -q q -q)(-q q -q q)))


;; The lists have different lengths 
(setf master-mat-length (max (length melo-mat-pitch)
                             (length melo-mat-velocity)
                             (length melo-voice-variant-variant)
                             (length melo-mat-length)
                             (length chord-mat-symbol)
                             (length chord-mat-velocity)
                             (length chord-mat-length)
                             (length bass-mat-pitch)
                             (length bass-mat-velocity)
                             (length bass-mat-length)
                             ))

;; Trim them to have the same
(setf 
 melo-mat-pitch (gen-trim master-mat-length melo-mat-pitch)
 melo-voice-variant-variant (gen-trim master-mat-length melo-voice-variant-variant)
 melo-voice-variant-tuplet (gen-trim master-mat-length melo-voice-variant-tuplet)
 melo-mat-velocity (gen-trim master-mat-length melo-mat-velocity)
 melo-mat-length (gen-trim master-mat-length melo-mat-length)
 chord-mat-symbol (gen-trim master-mat-length chord-mat-symbol)
 chord-mat-velocity (gen-trim master-mat-length chord-mat-velocity)
 chord-mat-length (gen-trim master-mat-length chord-mat-length)
 bass-mat-pitch (gen-trim master-mat-length bass-mat-pitch)
 bass-mat-velocity (gen-trim master-mat-length bass-mat-velocity)
 bass-mat-length (gen-trim master-mat-length bass-mat-length)
)


;; Pick material with one master index
(setf nbars 16
      master-index (rnd-sample nbars (gen-integer 0 (- master-mat-length 1)))
      melo-mat-pitch-picked (mapcar (lambda (x) (nth x melo-mat-pitch)) master-index)
      melo-voice-variant-variant (mapcar (lambda (x) (nth x melo-voice-variant-variant)) master-index)
      melo-voice-variant-tuplet (mapcar (lambda (x) (nth x melo-voice-variant-tuplet)) master-index)
      melo-mat-velocity (mapcar (lambda (x) (nth x melo-mat-velocity)) master-index)
      melo-mat-length (mapcar (lambda (x) (nth x melo-mat-length)) master-index)
      chord-mat-symbol-picked (mapcar (lambda (x) (nth x chord-mat-symbol)) master-index)
      chord-mat-velocity (mapcar (lambda (x) (nth x chord-mat-velocity)) master-index)
      chord-mat-length (mapcar (lambda (x) (nth x chord-mat-length)) master-index)
      bass-mat-pitch-picked (mapcar (lambda (x) (nth x bass-mat-pitch)) master-index)
      bass-mat-velocity (mapcar (lambda (x) (nth x bass-mat-velocity)) master-index)
      bass-mat-length (mapcar (lambda (x) (nth x bass-mat-length)) master-index)
)



;;; Create omn ------------
;;; 
;;; 

;; Assemble ---
(setf melody-omn (make-omn :pitch melo-mat-pitch-picked
                           :length melo-mat-length
                           :velocity melo-mat-velocity
                           :swallow nil)
      chords-omn (make-omn :pitch chord-mat-symbol-picked
                       :length chord-mat-length
                       :velocity chord-mat-velocity
                       :swallow nil)
      bass-omn (make-omn :pitch bass-mat-pitch-picked
                     :length bass-mat-length
                     :velocity bass-mat-velocity
                     :swallow nil))

;; Final voices ---
(setf 
 melody (filter-tie (velocity-to-dynamic (flatten-sublist (loop for me in melody-omn
                               for va in melo-voice-variant-variant
                               for tr in melo-voice-variant-tuplet
      collect (voice-variant (list me) :variant va :tuplet tr)))))
 ;;melody (velocity-to-dynamic melody-omn)
 chords (velocity-to-dynamic (drop-voicing chords-omn :type '(1 2) :leading 'l))
 bass (velocity-to-dynamic bass-omn))

;; Ambitus control
(length melody)
(setf melody (ambitus '(c4 c5) melody :section '(0 1 2 3)))
(setf melody (ambitus '(g4 g5) melody :section '(4 5 6 7)))
(setf melody (ambitus '(c5 c6) melody :section '(8 9 10 11)))
(setf melody (ambitus '(g5 g6) melody :section '(12)))
(setf melody (ambitus '(c4 c5) melody :section '(13 14)))
(setf melody (ambitus '(c4 c5) melody :section '(15 16)))

;; Preview ---

(ps 'gm
    :tempo 60
    :p (list (omn-to-time-signature melody '(4 4)) 
             chords)
    :bass (list bass))

;; Record MIDI
(compile-score *last-score*
               :output :midi
               :file (workspace-file "v.mid")
               :if-exists :new-index)

seed

Seed for this example was: 24113.

Opusmodus is really amazing for music production. Here’s a short orchestral test I’ve made today, the rendering is Sibelius and NotePerformer.

I’m sharing a short SATB piece together with its score code and MP3 file.

Hope you’ll find it inspiring and enjoyable!

Best,

Stéphane

Score240_SATB.opmo Score240_raw_OMPrintScore.pdf

Here’s a work in progress for ensemble.

Best

S.

I’d like to share a brief experimental study for a String Quartet based on an FM spectrum.

It is basically a test of VSL Solo Strings Studio’s microtonal capabilities with no real attempt to be musically developed or interesting.

However, it also serves as a test for my workflow with Lilypond.

Unfortunately, actually, even if I own Synchron Solo strings, I don't use them because the Sul Ponte and Sul Tasto are still not implemented in this new lib, so I continue to use the VSL Solo Strings studio version.

But microtonality works very well !

Best

Stéphane

Micro Stud S237-858649.pdf

Sadly, Barry Vercoe, the creator of Csound, passed away one week ago.

I've played a lot last week with Csound (I love Csound!) trying to build a cool workflow within Opusmodus for algo comp with Csound based on a premade instruments library I’ve started to build.

This allows me to focus on music when composing in Opusmodus with Csound.

Here are my first tests.

Be cautious of your monitors and ears!

The score and parts are available from American Composers Edition, New York.

American Composers Alliance

By the way, this project was also inspired through my studies of Stéphane Boussuge's various materials at his Composer Workshop. I highly recommend them.

Other possible applications: An initial pitch sequence evolves into a steady, constant pitch. A start pattern for velocity gradually shifts towards a fixed velocity.

(defun gen-acc/rit (alist endvalue) ;; startpattern + endvalue
  (loop while (not (equal alist (gen-repeat (length alist) endvalue))) 
          collect (setf alist (loop for i in alist
                                    when (/= i endvalue)
                                      collect (if (> i endvalue)
                                                     (- i 1)
                                                  (+ i 1))
                                 else collect i))))


(list-plot (flatten (gen-acc/rit '(1 7 4 2 11 9 5 3) 3)) :join-points t :style :fill)

=> ((2 6 3 3 10 8 4 3) (3 5 3 3 9 7 3 3) (3 4 3 3 8 6 3 3) (3 3 3 3 7 5 3 3) (3 3 3 3 6 4 3 3) (3 3 3 3 5 3 3 3) (3 3 3 3 4 3 3 3) (3 3 3 3 3 3 3 3))


(list-plot (flatten (gen-acc/rit '(1 7 4 2 11 9 5 3) 15)) :join-points t :style :fill)

=> ((2 8 5 3 12 10 6 4) (3 9 6 4 13 11 7 5) (4 10 7 5 14 12 8 6) (5 11 8 6 15 13 9 7) (6 12 9 7 15 14 10 8) (7 13 10 8 15 15 11 9) (8 14 11 9 15 15 12 10) (9 15 12 10 15 15 13 11) (10 15 13 11 15 15 14 12) (11 15 14 12 15 15 15 13) (12 15 15 13 15 15 15 14) (13 15 15 14 15 15 15 15) (14 15 15 15 15 15 15 15) (15 15 15 15 15 15 15 15))


(list-plot (flatten (gen-acc/rit '(1 2 3 1 5 7 11 3 13 ) 6)) :join-points t :style :fill)

=> (((4 6 2 6 2 12 3 4 10) (5 6 3 6 3 11 4 5 9) (6 6 4 6 4 10 5 6 8) (6 6 5 6 5 9 6 6 7) (6 6 6 6 6 8 6 6 6) (6 6 6 6 6 7 6 6 6) (6 6 6 6 6 6 6 6 6))

This text outlines a specific aspect of a larger project I am developing for live electronics and instruments. Since the work heavily involves live electronic processing in real time, it is based on a MaxMSP patch that I am currently building.

An important component of this system involves integrating OPUSMODUS for certain compositional processes—specifically, the processing of pitch material collected in real time via a pitch follower from an improvising musician.

In MaxMSP, this means that every few seconds, the most recently played pitches (as MIDI note numbers) are saved into a .txt file. Meanwhile, in OPUSMODUS, I run a routine that checks once per second whether a new pitch list has been saved (i.e., a list that differs from the previous one). If a new list is detected, I generate an OMN sequence based on this list and export it as a MIDI file.

Only ten MIDI files are generated and continuously overwritten in a rotating manner. These MIDI files can then be precisely triggered within MaxMSP (e.g., when a specific pitch is detected, a stored MIDI file is played back) and integrated into the live electronic performance.

Essentially, the system acts as a memory/archive that is generated from the live improvisation of the performer. Through a specific grammar created in OPUSMODUS, this musical material can then be re-injected into the live setting, forming a loop between improvisation, analysis, and compositional feedback.

Another development step would be to replace the current .txt-based communication with a direct OSC (Open Sound Control) connection, streamlining the entire process.

could sound like this: electric feedbacker guitar (live and improvised) + this system (in a test setup)