Audiobus: Use your music apps together.

What is Audiobus?Audiobus is an award-winning music app for iPhone and iPad which lets you use your other music apps together. Chain effects on your favourite synth, run the output of apps or Audio Units into an app like GarageBand or Loopy, or select a different audio interface output for each app. Route MIDI between apps — drive a synth from a MIDI sequencer, or add an arpeggiator to your MIDI keyboard — or sync with your external MIDI gear. And control your entire setup from a MIDI controller.

Download on the App Store

Audiobus is the app that makes the rest of your setup better.

Learn to Program the Mozaic Workshop to create MIDI FX and Controllers *you could learn something*

123457

Comments

  • McDMcD
    edited April 2020

    @hypnopad said:
    @hes said Of course, I do get that if you don't understand the code then it may as well be a black box.

    Forget the code... tweak the data and play. You liked E4:

    Base_Note = 64
    Sequence = [1,2,3,5,7,8,6,5,4,5,2,3,5,4,3,2]
    Scale = [1,3,4,6,8,9,11,13,15,16,18,20,21,23,25]
    Length = 16
    delay = 600
    Octave = 4

    Change the melody:
    Sequence = [1,3,5,2,4,6,3,5,7,9,7,5,7,5,3,2]
    Sequence = [1,8,2,9,3,10,9,2,6,7,8,9,7,5,3,2]
    Sequence = [1,2,3,5,4,5,6,8,2,3,4,6,5,7,4,2]

    Slow it down and drop an octave:
    delay = 2000
    Octave = 2

    It's really just typing. Not really coding.

    Which feature update would get you most interested in more testing?
    Knobs ( change scales, transpose, root, delay, octaves)
    PAD's to set customer sequences (using PAD's like the white key on a piano to select scale notes).

    What's the best way to speed testing? AUM projects with pre-loaded scripts to test and pre-coded to s Base_Note. Maybe a project with 12 Base_Notes. What are the best base notes to target for typical Drum Pads. I haven't even broken out my Kat Pad yet to play.
    I just poke the AUM keyboard and that keeps me busy. Tweaking and auditioning targets for great sounds. I'm really digging the IAP"s in "Noise Melody" lately. (Just be careful with the Swan IAP"s that only working with the internal Noise keyboard or real Roli hardware controllers. But there other IAP's are great.

  • @McD The very first thing that needs to happen is stuck note prevention. The synths are apparently not getting any note offs.I get nothing but hung notes(see my @wim suggestion?).From what I can tell lowest velocity plays random(?)chords. Higher velocities play more notes in chosen numbered scale. Not really a simple round robin but more like a velocity modulated midi delay/transposer?
    Sharing AUM projects work.Your knob parameters choices sound good. Your base notes selection-I don’t know if it matters. I see myself using multiple instances of this. One per track/note in AUM each triggering its own synth rather than one instance in one track with multiple note inputs for different scales of one sound. I could just use a midi note filter to sort it out if you kept it multi note.

  • @hypnopad said:
    @McD The very first thing that needs to happen is stuck note prevention.

    OK.

    From what I can tell lowest velocity plays random(?)chords. Higher velocities play more notes in chosen numbered scale. Not really a simple round robin but more like a velocity modulated midi delay/transposer?

    No my invention in this Object was to convert velocity into the number of notes emitted. How many would you prefer... one per tap? Easy. A Drum pad produces the timing details which just triggers one of more notes but I wanted to do something new with the velocity details. Worth a try.

    Sharing AUM projects work

    .Your knob parameters choices sound good.

    I think so too. I can go crazy with knobs but the code becomes more and more complex. I'm thinking
    I want more simple Objects delivered in AUM in one load. But open each would expose knobs to
    make that one do something... transpose. Play harmony notes in relation to the ones above and below.
    So, 3 instances create chords per tap but you can use knobs to generate chords that you like. I just take the notes above and below and add some integer value:

    1
    3
    5
    defines a simple 3 note triad.

    -7
    1
    5
    10
    defines a big open voiced chord.

    One app with multiple instances and different Knobs settings... I hope you see the benefits of simple scripts users can change, tweak and stack creatively in AUM. Edit the data (which is what the Knob really does... change default data).

    Your base notes selection-I don’t know if it matters. I see myself using multiple instances of this. One per track/note in AUM each triggering its own synth rather than one instance in one track with multiple note inputs for different scales of one sound. I could just use a midi note filter to sort it out if you kept it multi note.

    I pass thru the original NOTE so one tap can actually trigger a tree of objects. But you could alternatively
    configure Objects per PAD device site AUM is so powerful for plumbing FX and Apps.

  • No my invention in this Object was to convert velocity into the number of notes emitted. How many would you prefer... one per tap? Easy. A Drum pad produces the timing details which just triggers one of more notes but I wanted to do something new with the velocity details. Worth a try.

    That’s what I thought. I’ll try a different controller to see if that helps. I kept getting chords on soft strikes.
    One per tap would be great but I see a use for this delay type thing also. I would use both.
    Definitely a lot of potential using multiple simple scripts too.

  • @hypnopad said:
    One per tap would be great but I see a use for this delay type thing also. I would use both.
    Definitely a lot of potential using multiple simple scripts too.

    I think when I get a few basic simple "Objects" with Knobs and the "hung note fix" I'll zip them up and
    Patchstorage can deliver a *zip file of them. Then they end up in a Subdirectory of Mozaic and I might
    also put AUM projects in the text description on PatchStorage along with some SoundCloud demos to
    inspire people to want to give it a play.

  • edited April 2020

    haven’t had a single hung note..

  • heshes
    edited April 2020

    Regarding hung notes, how confident are we that they're actually a result of the synth getting overloaded and skipping a note off? I would look for other causes before resorting to that as an explanation.

    Is there a simple way to replicate the note off problem? If so, log the midi that's actually getting sent to the synth to confirm whether or not each NoteOn command has a corresponding NoteOff command. Distilling problem down into simplest set of steps to replicate is the best way to approach quashing bugs. "Hung notes everywhere" is not real helpful. "A hung note when, immediately after I load the script, I press Middle-C" is feedback that can really help.

    I haven't fully grokked the code, but it looks to me like there's a spot where NoteOff command may not be getting sent properly. Look at the SendMidi commands in this section:

    for i = 0 to Outer_Loop - 1
          if loop = Length
            loop = 0
          endif
    
          Sequence_Note = Sequence[loop]
          Note = Scale[Sequence_Note - 1] + (Octave * 12) - 1
          Inc loop
          new_delay = i * delay
          Log {Loop: }, loop, { Note: }, Note, { Velocity: }, MIDIVelocity, { Delay: }, 
          SendMIDIOut MIDICommand, Note, MIDIVelocity, new_delay
          SendMIDIOut MIDICommand, Old_Note, 0, new_delay
          Old_Note = Note
      endfor
    
    

    It looks to me like on the last time thru this loop that 'Note' is being turned on, and 'Old_Note' is being turned off. However, the loop then exits, and the 'Note' that was turned on in final pass does not get turned off. If so, then the fix may just be to add the final NoteOff command right after the for loop:

        endfor
       // turn Note from final pass in for-loop off
        SendMidiNoteOff MIDIChannel, Old_Note, 0, new_delay
    

    There will be a NoteOff command from the user unpressing the key on the keyboard that gets sent elsewhere using 'SendMidiThru', but that note is likely not the same note as the one that was turned on in the final pass of the loop.

    Also, just for clarity, I would probably change those two SendMidiOut commands to one SendMIDINoteOn and one SendMIDINoteOff command.

    Or maybe I just haven't looked closely enough.

  • Also, this 'elseif' statement has no condition following it:

      elseif
        SendMIDIThru  
      endif
    

    I think that should be generating a syntax error, since elseif should always be followed by an expression. What you want there is a simple 'else' to catch every other condition. Without any condition at all (and no flagging of the elseif as a syntax error) I wonder whether it's evaluating the elseif as having an always true condition (in which case it's the same as a bare 'else') or as having an always false condition (in which case that SendMidiThru is never getting executed).

  • edited April 2020

    Some apps don't understand the NoteOn short-form for NoteOff - which was designed for packing multiple notes in the same event.

    In other words, switching to explicit NoteOff event may help with stuck notes - unless Mozaic is already doing this behind the curtain.

  • heshes
    edited April 2020

    @mojozart said:
    Some apps don't understand the NoteOn short-form for NoteOff - which was designed for packing multiple notes in the same event.

    In other words, switching to explicit NoteOff event may help with stuck notes - unless Mozaic is already doing this behind the curtain.

    Yes. As is the SendMidiCommands are sending two NoteOn commands (guaranteed since we know the MidiCommand variable is 144), with one having a velocity of 0. If you wanted to continue using the SendMidiCommand form, you'd want to change it to expressly send NoteOff command, using form like this: 'SendMidiCommand 0x80, [noteval], [vel], [delay]'. But expressly using SendMidiNoteOn and NoteOff commands seems better.

    Also, on second thought, I think you do want to have that 'else' be an 'elseif' with a condition that excludes certain NoteOff commands from getting sent thru. At least you do, if you're intending to send all your NoteOns and NoteOffs from BaseNote presses in the code for the main condition ('MidiCommand = 144 and MidiNote=BaseNote') of the If statement. It might not screw things up if you send the NoteOff from the user's keypress thru, but you aren't sending those NoteOns thru, so filter the NoteOff from user keypresses, too:

    elseif (MidiCommand = 0x80) and (MidiNote = BaseNote)  // don't send NoteOffs for BaseNote thru
       exit
    else 
      SendMIDIThru
    endif
    
  • heshes
    edited April 2020

    Another thought: I've never used the delay parameter in midi note commands, but is there any need for the OldNote variable and its associated logic at all?

    Why not just issue both NoteOn and NoteOff commands for 'Note' at the same time, but add a larger delay for the NoteOff command so Mozaic delays sending it for longer?:

          new_delay = i * delay
          [. . . ]
          SendMIDINoteOn  MidiChannel, Note, MIDIVelocity, new_delay
          SendMIDINoteOff MidiChannel, Note, 0, (new_delay + delay )
    

    Unless I'm missing something (which is possible) that should work, and simplify by letting you get rid of all the OldNote related stuff.

    Also, look at p.26 of the manual, regarding the 'delay' parameter it says:

    All SendMIDIxxxx commands let you add an optional delay parameter;
    the time in milliseconds before the message is sent out.
    If you leave out the delay parameter, Mozaic will assume you want to send the MIDI event out
    immediately. In this case we use the delay parameter to queue a note off message 500ms. afer the note
    on message. That’s convenient, because it means we don’t have to keep track of any notes that are
    playing! 
    

    I think this means that the midi commands are queued inside Mozaic and not sent until their time comes. If so, this means the synth isn't getting overloaded with lots of commands sent all at once; they're saved within Mozaic until Mozaic engine decides the time has come for them to be sent. (Another way of saying this is: 'Delay' parameter is not part of the midi standard; all midi note on and off commands are executed by the synth as soon as they're received; the delay parameter instead is parsed and applied within Mozaic.)

  • Here are some screen captures of the issues.
    High velocity from a KORG nanokey 2. Hanging note.

    Here is with medium and low velocity. One at 70 and one at 24. Low velocity creates a chord and then hangs.

    Hope this helps with a diagnosis.

  • McDMcD
    edited April 2020

    @hes said:
    Regarding hung notes, how confident are we that they're actually a result of the synth getting overloaded and skipping a note off? I would look for other causes before resorting to that as an explanation.

    Your instincts are good. I tried my Kat Pad controller and it sounds terrible. I quickly hacked on the code and got some nice short notes which work fern with FAC Alteza. Combined with a Note/Tap it's more useful.

    Do not be concerned about ownership if you want to create a variant. I would consider that to be a win.
    But I will continue making my own set of Objects. I cal them Objects to honor the idea of Object Oriented Programming. An Object is a bit of behavior with some internal data. Object Oriented programming combines networks of objects into full/complex applications. The benefit of objects are "re-use". So feel free to take the ideas and make some too. You'll have ideas I would never think of...mdas

    Here's the current code instance I'm playing with after some quick editing/hacking.
    I fixed the Note Off's and changed it to Tap per Note.

    @OnLoad
    
       Base_Note = 63
    
       Sequence = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]
       Scale = [1,2,4,5,7,8,10,11,13,14,16,17,19,20,22,23]
       Length = 16
       Octave = 4
       loop = 0
       delay = 100
       ShowLayout 2
       Old_Note = Scale[1] + (Octave * 12) - 1
    
    @End
    
    
    @OnMidiInput
    
        MIDItype = MIDICommand
        // Log {MIDI Command: }, MIDIType
        pad_note= MIDINote % 12 + 1
        if loop = Length
          loop = 0
        endif
        Sequence_Note = Sequence[loop]
        Note = Scale[Sequence_Note - 1] + (Octave * 12) - 1
        Inc loop   
        Log {Loop: }, loop, { Note: }, Note, { Velocity: }, MIDIVelocity, { Delay: }, 
        SendMIDIOut MIDICommand, Note, MIDIVelocity
        SendMIDIOut MIDICommand, Old_Note, 0, delay
    
    @End€
    

    Very simple. Note On and Note Off go out as a pair.
    NOTE: setting velocity = 0 is interpreted as a Note Off.

    So every Tap advances the "pointer" (loop) into the Sequence Array and gets reset at "length".

    Thank you for looking carefully at my malformed code that I posted here. This new script is less complex and behaves better. I did not do put the "Base_Note" detection test back in (yet) to use one Controller with multiple Pads like the prior version.

  • edited April 2020

    NOTE: setting velocity = 0 is interpreted as a Note Off.

    According to the spec yes, but not according to some apps.

    I would not be surprised if you have to work around these flawed implementations, as others have had to do.

  • @mojozart said:

    NOTE: setting velocity = 0 is interpreted as a Note Off.

    According to the spec yes, but not according to some apps.

    I would not be surprised if you have to work around these flawed implementations, as others have had to do.

    Then I would be well advised to use a real note off and will take your input. It's a small change to
    modify the MIDICommand to 129 or something like that. Eventually I'll memorize all these MIDI numbers in Decimal. Thank you @Brambos for not making us use Hex, Octal or Binary to set the right bits in these commands.

  • heshes
    edited April 2020

    There's another thing to check with these SendMIDIOut commands:

        SendMIDIOut MIDICommand, Note, MIDIVelocity
        SendMIDIOut MIDICommand, Old_Note, 0, delay
    

    These commands will always send midi over channel 0, regardless of what channel the original midi command came in on. This may seem like it's working fine, if the controller is in fact coming in on channel 0. But it's going to break, or work unexpectedly, if a user is sending on a different channel and expecting the midi commands to come out on the same channel they're going in on.

    You can read the explanation on p.33 of the manual, but I would expect you want to send it out on same channel it's coming in on, for which you'd need one of these:

        SendMIDIOut (MIDICommand+MidiChannel), Note, MIDIVelocity
        SendMIDIOut (MIDICommand+MidiChannel), Old_Note, 0, delay
    

    or, what is the same thing:

        SendMIDIOut MIDIByte1, Note, MIDIVelocity
        SendMIDIOut MIDIByte1, Old_Note, 0, delay
    

    I would vote for using SendMidiNoteOn, and SendMidiNotOff myself, which would also clarify that you need to indicate what channel you're using (because the 'MidiCommand' part of those commands -- 0x90 and 0x80 -- is implicit, not stated at all).

  • @hes said:
    I would vote for using SendMidiNoteOn, and SendMidiNotOff myself, which would also clarify that you need to indicate what channel you're using (because the 'MidiCommand' part of those commands -- 0x90 and 0x80 -- is implicit, not stated at all).

    I'm in total agreement. Use a variable for the MIDIchannel and I'll look for the right MIDIcommand decimal that doesn't require a velocity = 0 and still is accepted as a valid Note Off.

    Here's the guidance in @Brambos' Mozaic Manual:

    This is particularly useful because we can now easily check the command, without having to worry about channel data getting in our way:

    if MIDICommand = 144
    // this is a Note On command (in hex: 0x90)
    else if MIDICommand = 128
    // this is a Note Off command (in hex: 0x80)
    endif
    

    Simply add MIDIChannel to MIDICommand to recreate the original command byte:

    if MIDIByte1 = ( MIDICommand + MIDIChannel ) Log {Yeah, this should be identical!}
    else
      Log {You will never see this text}
    endif
    

    He also provides Commands to send explicit NoteOn or NoteOff with you needing to specify the MIDIChannel and not stress over the 144 vs 128 decimal values to set the most significant bits in the command:

    SendMIDINoteOn 0, 35, 100
    SendMIDINoteOff 0, 35, 0, 300

    These coding details drive a lot of people crazy since they don't really care. That's why I want a bullet proof script BUT people can tweak the data like they would enter Notes in a Piano Roll.

    The trick is getting people out of their comfort zone to learn a bit more about the technical details.
    This is true with Synth's, Sequencers and MIDI effects. With a little effort a whole new level of expression is opened up over buying more apps that do similar magic for $5 a pop.

  • OK... I got a chance to try the "One Tap per Note" script with 7 Zeeon instances.

    Here's a a folder with a copy of the AUM project that will load the 7 scripts and uses the Zeeon Synth for targets. And the Mozaic Script used with sequence variations and input notes that match my KatPad with 2 pedals (kick and hi-hat inputs).

    https://www.dropbox.com/sh/pflln5xhsytct2g/AACrBsRTDfDJmTgR0GgGg0nfa?dl=0

    Here's the script... it's "Tap per Note" and doesn't hang notes.

    @OnLoad
    
     // change this to the note of the paired Hardware Controller (Drum Pads optional)
     // picking notes on a Keyboard works just fine too. But it's create for tapping out sequenced rhythms 
     Base_Note = 36 // change this to the note of the paired Hardware Controller (Drum Pads optional)
    
     Sequence = [1,5,8,5,1,5,9,8,1,5,8,5,8,5,2,3]
     Scale = [1,3,4,6,8,10,11,13,15,16,18,20,22,23,25]
     Length = 4
     // Sequence = [1,2,3,5,7,8,6,5,4,5,2,3,5,4,3,2]
     Octave = 3
     loop = 0
     delay = 200
     ShowLayout 2
    
    @End
    
    
    @OnMidiInput
    
      if MIDICommand = 144 and MIDINote = Base_Note
        if MIDIVelocity = 0
          exit
        endif  
        MIDItype = MIDICommand
        pad_note= MIDINote % 12 + 1
        if loop = Length
          loop = 0
        endif
        Sequence_Note = Sequence[loop]
        Note = Scale[Sequence_Note - 1] + (Octave * 12) - 1
        Log {Note: }, Note
        Inc loop
        SendMIDIOut MIDICommand, Note, MIDIVelocity
        SendMIDIOut MIDICommand, Note, 0, delay
      endif
    
    @End€
    
  • Yeah. Now we’re getting somewhere! Nice demo too.

  • I made a couple more Kat Pad Jams using these scripts... they just differ in the incoming note, sequences numbers and the delay values... otherwise there are 6 instances of the same basic code (bass drum, hi-hat pedal and 4 Pads):

  • Nice. Melodic round robin is fun to play isn’t it?

  • Couple questions. I know the base note is the note coming from your controller but is it always also the 1 (root note) in the scale? What does delay do if the notes are tapped and don’t rely on being sequenced ?

  • @hypnopad said:
    Couple questions. I know the base note is the note coming from your controller but is it always also the 1 (root note) in the scale?

    No. The Base_Note is just a detail for the script to trigger for a given pad. The scale root (so far) is C and the sales I've been using lately are C dorian (which is a nice minor). I'd like to start implementing some knobs to allow changes in key, scales and "offsets" so 2 instances could play parallel intervals and 3 could be set to chord relationships.

    What does delay do if the notes are tapped and don’t rely on being sequenced?

    The delay always determines how long each note rings... adding massive reverbs helps make things sound more legato but the reverb is suppling the Sustain and Release. The instrument selected determines the attack and the Delay variable is effectively the Decay in the ADSR envelope model.

    Turn off the reverbs and the notes will sound like beeps with short delays and like full notes with 1000+ msec delays. Delay can be second long too if you want to avoid those massive reverbs on everything.

    I made a Phillip Glass sounding track using Pad Objects, "One Finger Orchestra" fr the constant Kraftwerk-like rhythm background and the Enso AU Looper. I like these AUM projects because it seems to come back ready to perform.

  • Thanks for the clarifications. Delay between note on and off - note length. Got it. All your future options sound good . At some point it would be nice to work on velocity. I take it now it’s all set to a static amount? Would be great to either be able to set it manually for each of the numbers in the sequence OR just let it pass through and have all notes respond to your playing dynamics.
    Nice demo also.

  • McDMcD
    edited April 2020

    @hypnopad said:
    Thanks for the clarifications. Delay between note on and off - note length. Got it. All your future options sound good . At some point it would be nice to work on velocity. I take it now it’s all set to a static amount?

    No. the velocity of the tap is applied the the sequenced note so you should hear accents it you play them.

    Would be great to either be able to set it manually for each of the numbers in the sequence OR just let it pass through and have all notes respond to your playing dynamics.

    They should respond if I didn't mess it up.

    Nice demo also.

    I'm starting to enjoy the generative approach to a live session. I could see making a dozen AUM projects and doing a live performance or busking with an iPhone and a Kat Pad tapped with my hands.

    Everything would fit in a backpack. I should look at the power specs of the Kat Pad to see if it can run from a battery pack. The Kat wants 9 Volts and everything I have is 5V... darn.
    I should shop for a 9V battery adapter cable to see if I can still do this. All those Guitar Pedals expect 9V so there maybe something to power those but they typically just have a 9V battery slot as an option. The external power port is the exception and not the rule.

    A little MIDI keyboard would also suffice with Mozaic sequencing for the background textures like Kraftwerk loops. Now I want an EWI to play midi synth solos over the top
    with breath controls. I just keep expanding my little bag of tricks. So much fun.

  • No. the velocity of the tap is applied the the sequenced note so you should hear accents it you play them.

    You are right. That’s really weird. I was testing on the first Zeeon and for some reason it wasn’t responding to velocity even though my midi monitor said it was receiving it. Maybe I’m not understanding Zeeon’s way of handling velocity. Other tracks with Zeeon seemed fine too. Just that first one.
    I did experience a cpu spike/ audio silence while playing the keyboard while adjusting the script- sequence length maybe? Not sure.
    I’m getting more comfortable with typing in values in the script. Can’t wait for adjustable root notes!

  • McDMcD
    edited April 2020

    @hypnopad said:
    I’m getting more comfortable with typing in values in the script. Can’t wait for adjustable root notes!

    Cool. Add these lines and you can change the root without a knob:

    root = 0 // you may shift up by 1/2 steps 1 = C#, 2 = D, 3 = Eb .... up to B = 11
                   // or down using negative numbers B = -1, Bb = -2
    

    Then any MIDIOut lines just need to addd this value to the Note calculation which currently is:

    Note = Scale[Sequence_Note - 1] + (Octave * 12) - 1

    So to to transpose add the new root variable:

    Note = Scale[Sequence_Note - 1] + (Octave * 12) - 1 + root

    Modified Script with root variable option:

    @OnLoad
    
     Base_Note = 36 // change this to the note of the paired Hardware Controller (Drum Pads optional)
    
     root = 0
    
     Sequence = [1,5,8,5,1,5,9,8,1,5,8,5,8,5,2,3]
     Scale = [1,3,4,6,8,10,11,13,15,16,18,20,22,23,25]
     Length = 4
     // Sequence = [1,2,3,5,7,8,6,5,4,5,2,3,5,4,3,2]
     Octave = 3
     loop = 0
     delay = 200
     ShowLayout 2
    
    @End
    
    
    @OnMidiInput
    
      if MIDICommand = 144 and MIDINote = Base_Note
        if MIDIVelocity = 0
          exit
        endif  
        MIDItype = MIDICommand
        pad_note= MIDINote % 12 + 1
        if loop = Length
          loop = 0
        endif
        Sequence_Note = Sequence[loop]
        Note = Scale[Sequence_Note - 1] + (Octave * 12) - 1 + root
        Log {Note: }, Note
        Inc loop
        SendMIDIOut MIDICommand, Note, MIDIVelocity
        SendMIDIOut MIDICommand, Note, 0, delay
      endif
    
    @End€
    
  • I obviously don’t know how to properly set this up. Was I supposed to copy both sections of code? Only the second? You’ll have to make it way more simple for me. It doesn’t seem to be working. Instead of me copying and pasting willy nilly it would be best for now to send it as a simple AUM project with the new preset already saved.

  • @hypnopad said:
    I obviously don’t know how to properly set this up. Was I supposed to copy both sections of code? Only the second? You’ll have to make it way more simple for me. It doesn’t seem to be working. Instead of me copying and pasting willy nilly it would be best for now to send it as a simple AUM project with the new preset already saved.

    Will do.

    Here are the steps I will do.

    Open one of the Mozaic scripts. I have 6 of them. I will open the code section in the GUI and high light all the text until it asks what I want to do with it. I will high light the text above and select it to the clip buffer. When I click in the empty code box now I can used "Control V" to copy in the new text.

    Then I save the Script in the GUI. I'll load it since all Mozaic instances share the save folder of scripts.
    Once loaded in the other 6 scripts I'll save them with unique names and do a bit of testing. I'll make
    "root = 2" moving the tonal center to D. Test a bit and save the AUM.project and upload it into
    a DropBox folder and post a link here your for and others to test the updated version.

    Given a a day to move the ball forward. I appreciate your interest in the functionality. Ideally you should only have to edit variables in the @OnLoad section at various stages and I'll always make an AUM project available since it saves everyone a lot of extra "text processing" that comes with coding.
    Developer's love tools to make this all easier and Mozaic is pretty rudimentary in this regard.

  • 👍🏻

Sign In or Register to comment.