After extensive testing and discussion with the MuseScore community, it has been identified that MuseScore’s import engine requires an explicit sound tag, such as sound pizzicato="yes", within the MusicXML code to trigger a playback change. While other software like Sibelius or StaffPad can "infer" the sound from the words tag, MuseScore follows a literal interpretation and ignores the instruction if the explicit sound tag is missing.

This creates a significant bottleneck in the workflow, especially for those of us using Opusmodus for automated score generation, as every articulation must be manually re-mapped after each import.

I am asking if it would be possible to update the Opusmodus export engine to include these explicit sound tags alongside the textual directions. This would ensure seamless interoperability and a much smoother transition from algorithmic composition to final notation and playback across all platforms.

Thank you.

Here's a use-case example where this is a problem, a melody line which should not be handled in last bar to not make use of tonality but rather stay untouched.

So in the code line (tonality-map scale-tonality <> :time '(w) :exclude '(7))

I would like to define :time and :exclude together, but OM throughs the error Error: :exclude and :time can't be used together.

(asdf:load-system :arrows)


;; Function to extract pitches of chord, n is 1 indexed
;; Maybe obsolete, by using pitch-demix, to be explored.
(defun filter-chord-pitch (x n)
  "Filter pitches of a list of chords, removing root and fifths"
  ;
  ; Helper function for one chord
  (defun filter-one-chord-pitch (x n)
    (setf chord-melodized (pitch-melodize x))
    (chordize (mapcar (lambda (i) (nth (- i 1) chord-melodized)) n))
  )
  ; Apply for a list of chords 
  (loop for chord in x
          collect (filter-one-chord-pitch chord n))
)



;; Define Chord-Track
(setf chord-track 
      (arrows:-<>
       '(w (a3 m7) 
         w (d3 m7) 
         w (g3 7)
         w (c3 maj7)
         w (eb m7)
         w (ab3 7)
         w (db3 7)
         w (fs3 maj7)
         )
       ))
(setf total-span 8)

;; Derive harmonic environment from chordtrack
; derive scale for chord
(setf parent-scale 
      (arrows:-<>
       (find-parent-scale-for-chord (omn :pitch chord-track) 
                                    :scales '(lydian))
       (flatten-sublist)
       ))
(setf scale (mapcar 'second parent-scale))
(setf root (mapcar 'first (expand-tonality parent-scale)))
(setf scale-tonality (tonality-series scale :root root :map 'octave ))

; for bass
(setf base-pitches (filter-chord-pitch (mclist (omn :pitch chord-track)) '(1 3)))
(setf chord-track-base (omn-replace :pitch (flatten-sublist base-pitches) chord-track))
(setf bass-path (get-harmonic-path chord-track-base :time 'w))

; for melody
(setf character-pitches (filter-chord-pitch (mclist (omn :pitch chord-track)) '(2 3 4)))
(setf chord-track-character (omn-replace :pitch (flatten-sublist character-pitches) chord-track))
(setf harm-path (get-harmonic-path chord-track-character :time 'w))
; optional overwrite last bar
(setf harm-path (append (subseq harm-path 0 7) (last bass-path)))
      
;; Piano Comping
(setf non-bass-pitches (filter-chord-pitch (mclist (omn :pitch chord-track)) '(2 3 4 5)))
(setf chord-track-non-bass (omn-replace :pitch (flatten-sublist non-bass-pitches) chord-track))

(setf chord-omn
      (arrows:-<>
      chord-track-non-bass
       (omn-to-time-signature <> '(4 4))
       (drop-voicing <> :type '(2) :leading 't)
       ))


;; Rhodes Melody
(setf slonimnsky 
      (arrows:-<>
       (library 'slonimsky 'tritone nil :random 12)
       (transpose 0)
       (length-span total-span <>)
       ))

(setf melody-omn
      (arrows:-<>
       slonimnsky
       (omn-to-time-signature <> '(4 4))
       (omn-replace :length (rnd-sample total-span '((h h)(-q h q))) <>)
       (length-span total-span <>)
       (closest-path <> :ambitus '(c4 c5))
       (omn-to-time-signature <> '(4 4))
       (harmonic-path harm-path <> 
                      :time 'w :octave 'seq :type '(a d))
       (filter-tie)
       (passing-intervals '((3 (1 1 1)(1 2))
                            (-3 (1 1 1)(1 2))
                            (4 (2 2)(3 1))
                            (-4 (-2 -2)(-3 -1))
                            (5 (2 3)(3 2))
                            (-5 (-2 -3)(-3 -2))
                            ) <> :exclude '(7))
       (omn-to-time-signature <> '(4 4))
       (tonality-map scale-tonality <> :time '(w) :exclude '(7))
       (filter-tie)
       (omn-replace :velocity (rnd-sample total-span '((p) (mp) (mf) (f))) <>)
       (velocity-to-dynamic)
       (ambitus '(c4 c5) <>)
       ))


;; Bass
(setf bass-omn
      (arrows:-<>
       (make-omn :pitch '(c2 g2 c3 e2 c2)
                 :length (pcs-rhythm '3-11 :points 9 :legato t)
                 :velocity '((f mf mp p mf) ))
       (length-span 1 <>)
       (omn-to-time-signature <> '(4 4))
       (length-span total-span <>)
       (harmonic-path bass-path <> :time 'w :octave 'seq)
       (omn-to-time-signature <> '(4 4))
       ))


;; Output
(def-score test
    (:title "Harmonic Path"
     :key-signature 'chromatic
     :time-signature '(4 4)
     :tempo 98)
  (Piano
   :omn (list melody-omn)
   ;:port "Bus 1" 
   :sound 'gm :program 'acoustic-grand-piano 
   )
  (Pad
   :omn (list chord-omn)
   ;:port "Bus 2"
   :sound 'gm :program 'acoustic-grand-piano
   )
  (Bass
   :omn (list bass-omn)
   ;:port "Bus 3"
   :sound 'gm :program 'acoustic-grand-piano
   )
)

(audition-musicxml-last-score)

If the harmonic rhythm follows the time-signature, this is IMHO not a big problem.

So this code in line (tonality-map scale-tonality <> :exclude '(7)) works.

Still I think it would be great to have both parameters :time and :exclude in own control. (I assume parameter :section is affected as well).

I assume the current mutual exclusivity setting is due to the fact that both may contradict each other, but as you can see from example I use only one '(w) in :time and by defaut trust in recycling. I think in this way there is no conflict to request for an explicite :exclude which I would consider as an override..

@opmo Is this possible ?

(asdf:load-system :arrows)


;; Function to extract pitches of chord, n is 1 indexed
(defun filter-chord-pitch (x n)
  "Filter pitches of a list of chords, removing root and fifths"
  ;
  ; Helper function for one chord
  (defun filter-one-chord-pitch (x n)
    (setf chord-melodized (pitch-melodize x))
    (chordize (mapcar (lambda (i) (nth (- i 1) chord-melodized)) n))
  )
  ; Apply for a list of chords 
  (loop for chord in x
          collect (filter-one-chord-pitch chord n))
)



;; Define Chord-Track
(setf chord-track 
      (arrows:-<>
       '(w (a3 m7) 
         w (d3 m7) 
         w (g3 7)
         w (c3 maj7)
         w (eb m7)
         w (ab3 7)
         w (db3 7)
         w (fs3 maj7)
         )
       ))
(setf total-span 8)

;; Derive harmonic environment from chordtrack
; derive scale for chord
(setf parent-scale 
      (arrows:-<>
       (find-parent-scale-for-chord (omn :pitch chord-track) 
                                    :scales '(lydian))
       (flatten-sublist)
       ))
(setf scale (mapcar 'second parent-scale))
(setf root (mapcar 'first (expand-tonality parent-scale)))
(setf scale-tonality (tonality-series scale :root root :map 'octave ))

; for bass
(setf base-pitches (filter-chord-pitch (mclist (omn :pitch chord-track)) '(1 3)))
(setf chord-track-base (omn-replace :pitch (flatten-sublist base-pitches) chord-track))
(setf bass-path (get-harmonic-path chord-track-base :time 'w))

; for melody
(setf character-pitches (filter-chord-pitch (mclist (omn :pitch chord-track)) '(2 3 4)))
(setf chord-track-character (omn-replace :pitch (flatten-sublist character-pitches) chord-track))
(setf harm-path (get-harmonic-path chord-track-character :time 'w))
; optional overwrite last bar
(setf harm-path (append (subseq harm-path 0 7) (last bass-path)))
      
;; Piano Comping
(setf non-bass-pitches (filter-chord-pitch (mclist (omn :pitch chord-track)) '(2 3 4 5)))
(setf chord-track-non-bass (omn-replace :pitch (flatten-sublist non-bass-pitches) chord-track))

(setf chord-omn
      (arrows:-<>
      chord-track-non-bass
       (omn-to-time-signature <> '(4 4))
       (drop-voicing <> :type '(2) :leading 't)
       ))


;; Rhodes Melody
(setf slonimnsky 
      (arrows:-<>
       (library 'slonimsky 'tritone nil :random 12)
       (transpose 0)
       (length-span total-span <>)
       ))

(setf melody-omn
      (arrows:-<>
       slonimnsky
       (omn-to-time-signature <> '(4 4))
       (omn-replace :length (rnd-sample total-span '((h h)(-q h q))) <>)
       (length-span total-span <>)
       (closest-path <> :ambitus '(c4 c5))
       (omn-to-time-signature <> '(4 4))
       (harmonic-path harm-path <> 
                      :time 'w :octave 'seq :type '(a d))
       (filter-tie)
       (passing-intervals '((3 (1 1 1)(1 2))
                            (-3 (1 1 1)(1 2))
                            (4 (2 2)(3 1))
                            (-4 (-2 -2)(-3 -1))
                            (5 (2 3)(3 2))
                            (-5 (-2 -3)(-3 -2))
                            ) <> :exclude '(7))
       (omn-to-time-signature <> '(4 4))
       (tonality-map scale-tonality <> :exclude '(7))
       (filter-tie)
       (omn-replace :velocity (rnd-sample total-span '((p) (mp) (mf) (f))) <>)
       (velocity-to-dynamic)
       (ambitus '(c4 c5) <>)
       ))


;; Bass
(setf bass-omn
      (arrows:-<>
       (make-omn :pitch '(c2 g2 c3 e2 c2)
                 :length (pcs-rhythm '3-11 :points 9 :legato t)
                 :velocity '((f mf mp p mf) ))
       (length-span 1 <>)
       (omn-to-time-signature <> '(4 4))
       (length-span total-span <>)
       (harmonic-path bass-path <> :time 'w :octave 'seq)
       (omn-to-time-signature <> '(4 4))
       ))


;; Output
(def-score test
    (:title "Harmonic Path"
     :key-signature 'chromatic
     :time-signature '(4 4)
     :tempo 98)
  (Piano
   :omn (list melody-omn)
   ;:port "Bus 1" 
   :sound 'gm :program 'acoustic-grand-piano 
   )
  (Pad
   :omn (list chord-omn)
   ;:port "Bus 2"
   :sound 'gm :program 'acoustic-grand-piano
   )
  (Bass
   :omn (list bass-omn)
   ;:port "Bus 3"
   :sound 'gm :program 'acoustic-grand-piano
   )
)

(audition-musicxml-last-score)

This may further facilitate the (already phantastic options for) composition with OM in harmonic rich styles like Jazz.

My notation proposal see in option 3.

Musical example (hmmm OK, maybe a bit too simple as the bass is in the the chord, but still hopefully useful to illustrate the use-case):

;; Proposal for slash chord symbol notation support in OM
;;
;; Slash chords: https://en.wikipedia.org/wiki/Slash_chord
;;  - so these include inversions (as implemented already in OM)
;;  - BUT also other bass pitches not being present in original chord
;;  - Latter require special handling and are not supported in OM yet 
;;    (in chord symbols, as far as I know).
;;
;; Musical example: Stairway to Heaven (Led Zeppelin, Jimmy Page)
;; Chords:
;; Am, E/G#, C/G, D/F#, Fmaj7
;;


;; Option 1 -------------------
;
; This traditional way works somewhat, but it is a bit unnatural
; Cons: 
;      - rh and lh are separated and therefore harder to reason about and compose
;      - slash chords are not shown fully with bass as symbols in score

(setf stairway-rh '(w (a4 m)
                      (e4 maj)
                      (c4 maj)
                      (d4 maj)
                      (f4 maj7)))
(setf stairway-lh '(w a2 gs2 g2 fs2 f2))
(ps 'gm
    :title "Stairway to Heaven (Led Zeppelin, Jimmy Page) - Excerpt"
    :p (list stairway-rh stairway-lh)
    :tempo 98
    :time-signature '(4 4))



;; Option 2 -------------------
;
; This works a bit better
; Pros:
;      - rh and lh are less separated and therefore easier to reason about and compose
; Cons: 
;      - slash chords are not shown at all as symbols in score
;      - too much biolerplate in code

(setf stairway
      (append
       (chordize (append '(a2) (expand-chord '((a4 m)))))
       (chordize (append '(gs2) (expand-chord '((e4 maj)))))
       (chordize (append '(g2) (expand-chord '((c4 maj)))))
       (chordize (append '(fs2) (expand-chord '((d4 maj)))))
       (chordize (append '(f2) (expand-chord '((f4 maj7)))))
       ))
(ps 'gm
    :pg (list (make-omn :pitch stairway :length '(w) :span :pitch))
    :tempo 98
    :time-signature '(4 4))



;; Option 3 -------------------
;
; This IMHO would be ideal, but yet is not implemented in OM
; Just a proposal for notation, maybe there a better ways.
; Musicians please contribute!
; I believe the already supported symbols are great and
; I am not sure if my proposal is compatible.
;
; Pros:
;      - rh and lh are less separated and therefore easier to reason about and compose
;      - slash chords are shown as symbols in score
;      - less biolerplate in code

(setf stairway
      '(w (a4 m/a2)
          (e4 maj/gs2)
          (c4 maj/g2)
          (d4 maj/fs2)
          (f4 maj7/f2)))
=> (w (a4 m/a2) (e4 maj/gs2) (c4 maj/g2) (d4 maj/fs2) (f4 maj7/f2))

(ps 'gm
    :pg (list stairway)
    :tempo 98
    :time-signature '(4 4))
=> Error: OMN Parse Error: fail

• In rnd-sample, it would be nice to have a param controlling how smooth the result is, i.e. something like the "alfa" value in vector-smooth ( between 0 and 1 ) that allows you to smooth the result to some degree. For example, if I want a rnd-sample of a list of pitches, I could control how much the resulting pitch seq moves in steps or large jumps.

• In filter-repeat, the :position t :span :pitch option works great to prevent repeating X occurrences of pitches, but would it be possible to also have an option to prevent X occurrences of pitch classes?

For example, the below chooses pitches from 3 octaves of a major scale and prevents some repetitions of exact pitches. But if it returns something like c3 c4 d3 e3 d4 f5, then a filter on pitch class would only return c3 d3 e3 f5 for example.

(filter-repeat 4 (rnd-sample 128 (make-scale 'c3 22 :alt '(2 2 1 2 2 2 1))) :position t :span :pitch)

Finally, I'm not seeing documentation in the Assistant for some functions ( e.g. rnd-round, rnd-number, binary-invert and gen-white-noise ) which are referenced in the Composer Workshop courses. I'm on the latest version of OM 4 for Mac. Can this documentation be added?

II really enjoy the workflow from OPUSMODUS to Sibelius. When you have some little ideas for material, you program a small function, experiment with it, then export/open it in SIBELIUS and continue working. Not generating full scores, but small units of material… exporting by snippet-to-editor.

For example: (i could do it directly in SIBELIUS, but much easier via OPMO)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; binary-counting-rhythm -> counting from x to y // easy export to SIBELIUS
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; to ensure the pattern is always the same length, the bit length for all decimal-to-binary conversions is adjusted to match the largest decimal number
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defun dec-to-bin-rhythm (ilist)
  (let ((span (find-max (mapcar 'length (decimal-to-binary ilist)))))
	(loop for i in (binary-rhythm span ilist 1 :type 1)
                 collect (loop for x in i
                               when (< x 0)
                                 append (gen-repeat (abs x) 0)
                               else collect  x))))


(setf bitseq (dec-to-bin-rhythm (gen-integer 23 1))) ;; 5-bit
(snippet-to-editor 
 (omn-to-measure
  (make-omn :pitch '(cs3)
            :length (gen-length bitseq '1/8)
            :velocity '(mf)
            :articulation '(stacc))
  '(4/4)))



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; SIBELIUS opens the file -> copy/paste to the actual score
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

By the way, I am developing in programming language R with RStudio IDE.

Posit the developer company (formerly RStudio) of the IDE did a great job of integrating the service.

Basically its autocompletion on steroids.

The main benefit is that the more you comment your code about intention, the better the suggestions.

As side effect also my future me and other collabs will benefit from better commenting.

CoPilot is different to ChatGPT as its all happening during coding not inside a prompt.

CoPilot is more a pair programmer which keeps you in the flow.

I would love to have a similar experience when composing in the music creation continuum of OM.

@opmo It would be great to have also github CoPilot integrated in OM.

Below is a method I use a lot in generating rhythms in my compositions.

It generates a list of pulses of n units, where the pulses are assigned to prime indexes only.

I hope you find it useful.

All the best,

Jawher Matmati

;;; ====================================================

(defun gen-prime-pulses (nb &key (unit 's))

"Return a list of Nb OMN lengths:

index i is UNIT if i is prime, otherwise the corresponding rest (-UNIT).

Example: (gen-prime-pulses 10 :unit 's)

=> (-s -s s s -s s -s s -s -s -s)

NB: 0 and 1 are not prime; primes start at 2.

UNIT may be an OMN length symbol (s e q h w …) or a rational like 1/16."

(labels

((primep (n)

(and (> n 1)

(loop for d from 2 to (isqrt n)

never (zerop (mod n d)))))

(rest-of (u)

;; If UNIT is a symbol like 's -> make symbol '-s.

;; If UNIT is a ratio (e.g. 1/16) -> return negative ratio for rest.

(typecase u

(symbol (intern (format nil "-~a" u))) ; => -S (case-insensitive)

(rational (- u))

(integer (- u))

(float (- u)))))

(loop for i from 0 to (- nb 1)

collect (if (primep i) unit (rest-of unit)))))

;;; ====================================================

I have made a small function that generates a list of natural harmonics (at sounding pitch) :

• Builds a Markov walk over strings I–IV that never skips a string (I <-> II, II <-> I or II <-> III, III <-> IV, III <-> II, IV <-> III)

• At each step, picks a pitch from the selected instrument’s natural-harmonics list for that string.

• :repeat nil forbids immediate pitch repeats; :repeat t allows them.

• Key words

:instrument lets you choose the instrument (violin, viola, cello or bass)

:start, lets you define the starting string for the sequence

:repeat (t or nil), t allows identical consecutive notes; nil forbids (default t)

:seed, it of course for controling the reproducibility of the random output

Feel free to use it / modify it (for example adding a 5th string for the double bass), etc.

All the best,

Jawher Matmati

;;; ------------------------------------------------------------
;;; Library: Natural harmonics (sounding pitch) for strings
;;; ------------------------------------------------------------
;; Violin
(setf Vln-harm-nat-IV '(g4 d5 g5 b5 d5))
(setf Vln-harm-nat-III (pitch-transpose 7 Vln-harm-nat-IV))
(setf Vln-harm-nat-II (pitch-transpose 7 Vln-harm-nat-III))
(setf Vln-harm-nat-I (pitch-transpose 7 Vln-harm-nat-II))
;; Viola
(setf Vla-harm-nat-IV (pitch-transpose -7 Vln-harm-nat-IV))
(setf Vla-harm-nat-III (pitch-transpose 7 Vla-harm-nat-IV))
(setf Vla-harm-nat-II (pitch-transpose 7 Vla-harm-nat-III))
(setf Vla-harm-nat-I (pitch-transpose 7 Vla-harm-nat-II))
;; Cello
(setf Vlc-harm-nat-IV (pitch-transpose -12 Vla-harm-nat-IV))
(setf Vlc-harm-nat-III (pitch-transpose -12 Vla-harm-nat-III))
(setf Vlc-harm-nat-II (pitch-transpose -12 Vla-harm-nat-II))
(setf Vlc-harm-nat-I (pitch-transpose -12 Vla-harm-nat-I))
;; Bass
(setf Cb-harm-nat-IV '(e2 b2 e3 gs3 b3))
(setf Cb-harm-nat-III (pitch-transpose 5 Cb-harm-nat-IV))
(setf Cb-harm-nat-II (pitch-transpose 5 Cb-harm-nat-III))
(setf Cb-harm-nat-I (pitch-transpose 5 Cb-harm-nat-II))

;;; ------------------------------------------------------------
;;; Adjacent-string Markov transitions (no skipping over strings)
;;; ------------------------------------------------------------
(setf string-adjacent-transitions
'((I (I 1) (II 1))
  (II (I 1) (II 1) (III 1))
  (III (II 1) (III 1) (IV 1))
  (IV (III 1) (IV 1))))

;;; ------------------------------------------------------------
;;; gen-string-nat-harm-walk
;;; ------------------------------------------------------------
;; n number of notes to generate
;; :instrument 'Violin | 'Viola | 'Cello | 'Bass (default 'Violin)
;; :repeat t allows identical consecutive notes; nil forbids (default t)
;; :start 'first | '?' | one of 'I 'II 'III 'IV (default '?)
;; :seed integer for reproducible state walk (passed to GEN-MARKOV-FROM-TRANSITIONS)

(defun gen-string-nat-harm-walk
       (n &key (instrument 'violin) (repeat t) (start '?) seed)
  (labels
      (;; map (instrument, string) -> the corresponding harmonic list
       (string-pool (inst s)
         (case inst
           (violin (case s (I Vln-harm-nat-I) (II Vln-harm-nat-II)
                     (III Vln-harm-nat-III) (IV Vln-harm-nat-IV)))
           (viola (case s (I Vla-harm-nat-I) (II Vla-harm-nat-II)
                    (III Vla-harm-nat-III) (IV Vla-harm-nat-IV)))
           (cello (case s (I Vlc-harm-nat-I) (II Vlc-harm-nat-II)
                    (III Vlc-harm-nat-III) (IV Vlc-harm-nat-IV)))
           (bass (case s (I Cb-harm-nat-I) (II Cb-harm-nat-II)
                   (III Cb-harm-nat-III) (IV Cb-harm-nat-IV)))
           (otherwise (error "Unknown instrument: ~a" inst))))

       ;; is there at least one element in pool different from LAST?
       (has-alternative (pool last)
         (loop for p in pool thereis (not (eql p last))))

       ;; pick one pitch from the relevant pool; honour :repeat NIL
       (pick-pitch (pool last)
         (let ((choice (rnd-pick pool)))
           (if (and (not repeat) last (eql choice last) (has-alternative pool last))

               ;; re-pick until different (keeps pool weighting)
               (loop for c = (rnd-pick pool)
                     until (not (eql c last))
                     finally (return c))
             choice))))

    (let* ((states (gen-markov-from-transitions
                    string-adjacent-transitions
                    :size n :start start :seed seed)))
      (loop
         with last = nil
         for s in states
         for pool = (string-pool instrument s)
         for p = (pick-pitch pool last)
         do (setf last p)
         collect p))))

;;; ------------------------------------------------------------
;;; Examples
;;; ------------------------------------------------------------
;; 24 notes, start anywhere, forbid immediate repeats, for Violin:
(gen-string-nat-harm-walk 24 ; size of the list
                          :instrument 'violin
                          :repeat nil)

;; Start on string II, reproducible state-walk:
(gen-string-nat-harm-walk 24 :instrument 'viola :repeat t :start 'II :seed 123)

;; Cello, start on the first state in the table (I), no repeats:
(gen-string-nat-harm-walk 16 :instrument 'cello :repeat nil :start 'first)

I am looking for a way to control the high and low values in euclidean-rhythm function so as to increase or decrease the values (meaning increase or decrease the density of the rhythm) with a ramp or function?

What would be the best way to achieve this without resorting to assemble-seq?

Thank you very much for any suggestions or help and my apologies if this has been asked before,

JM

I posted this question to the forum a few days ago: https://opusmodus.com/forums/topic/3886-incorrect-pitch-notation-for-minor-key-in-def-score/#comment-13346. The main issue was that OM was respelling my accidentals when I rendered my score with def-score and set the key-signature to '(d minor). For example it was rendering cs4 as db4, etc. I partially solved the problem by setting the key-signature to 'chromatic or 'atonal. Now all the accidentals are rendered correctly as per my OMN. What's missing is that my score does not have a b-flat in the key signature.

My suggestion: Allow the key-signature parameter in def-score to specify a custom key-signature such that the OMN rendered in the is not respelled as per a common key signature. This could also allow composers to render uncommon key signatures like those found in some Bartok scores, like just having a b-flat and a-flat with no e-flat. I imagine it could look something like:
:key-signature '(bb ab), or ('bb fs) to combine sharps and flats.

OM is by far the most powerful software available for algorithmic composition, but I, maybe others, have gotten pretty quick with writing raw OMN to sketch out music I've written on paper or otherwise. In many cases, it can be a more efficient and ergonomic way of entering music than tools like Sibelius which often require switching between a mouse, keyboard (computer or musical).

Thanks for taking the time to read this.

An example of this, that I have been using in standalone mode is RapidComposer.

Rapid Composer

Overall it's a basic version of OM with a more extensive GUI.

It does however, host VST's making it very convenient to write in one environment without having to route midi and saving multiple documents per Project.

per the OMN docs: "Wouldn’t it be good to be able to do everything in one place?"

Yes please.

For example:

(setf m6 (rnd-order m2 :type :all :seed nil))

When evaluating the above as snippet notation, you could quickly go through a number of trials and then copy and paste the seed value that you like.

I have a simple suggestion:

- An option for assigning some sound for live playing in the midi entry option. Just a sound like a piano, for monitoring the midi input from the midi controller.

To make this, I usually have to open a DAW, put a VST sound, redirect to Opusmodus via virtual port.

- Sometimes is nice to work only with Opusmodus gm midi simple sounds just to sketch and reserving a better surprise of hearing with better libraries for later in the process.

Best

Julio

chatgpt bach corale3.opmo

The problem is the number of requests...you have to pay!

I don't know if this exists, but I couldn't find anything.

Would it be possible to implement an argument for a 24-tet and 48-tet subdivision?

That would really help me out a lot!

Best regards,

Tibor

Patrick

is it possible to print at once "steps 01-30" directly from opus modus or from a folder?

My request is for Opusmodus to provide a SendSysex function. I would like to be able to send the re-tuning sysex's from Opusmodus, and then it would be up to me to use its EDO-12-based notation to access where those re-tuned notes are. That way, I could use Opusmodus for full-spectrum microtonal composition in Opusmodus's much more feature-packed composition environment than my little personal system. Actually, my system isn't so little, but compared to Opusmodus it is, so I would really like to change over to the much richer Opusmodus, though not at the expense of the very flexible microtonality I currently enjoy.

I used to have a Black Corporation Deckard's Dream and Xerxes that also support MTS real-time tuning, which worked fine, but I sold them, keeping the multitimbral Kyra as the most practical option. The only other synth I know of that supports real-time tuning is Moog's Matriarch, but I've never tried one.

After a long gap, I upgraded to Ver 3.0 a few days ago! Noticed the announcement regarding the book "Fundamentals of Composition with Opusmodus". Is it available in e-book form? Hopefully that will be less expensive and more accessible!

- Rangarajajan