IMPORTANT: This is the last release in the Alda 1.x series, however Alda 2.x is now available!

Please go to https://alda.io/install to download and install the latest version of Alda.

Or, if you already have Alda (< 1.5) installed, you can run alda update twice. The first time will update to Alda 1.5.0, which has the ability to upgrade itself to Alda 2.0.0. Running alda update a second time will update to the latest version.

1.5.0 (2021-06-30)

• Updated the alda update mechanism to support updating to Alda 2.x.

• Print a PSA that Alda 2 is available on startup.

1.4.4 (2021-03-06)

• Added a -c / --client option to the alda version command. When included, only the Alda client version is printed, and not the server version.

1.4.3 (2020-09-29)

• Fixed the formatting of the :help load command (help text for the :load command) in the REPL. There were a couple of newlines missing.

• Fixed string formatting in the error message that you get when you place a marker at an unclear location. (See [alda-core PR

1.4.2 (2020-06-15)

• Fixed a bug where in some cases, a global attribute can be recorded a fraction of a millisecond too late, potentially resulting in parts/voices not picking up on the attribute change until it's too late.

1.4.1 (2020-04-17)

• Fixed a minor bug related to alternate endings / repetitions, where input like the following would fail to parse correctly:

  [[c] [d]'1]*1
  

  The bug had to do with using event sequences in combination with the alternate endings feature.

1.4.0 (2020-03-19)

• The volume change messages that end up in the MIDI sequences generated by Alda (the values come from the Alda track-volume attribute) used to be Channel Volume (7) messages, but are now Expression (11) messages.

  As [truj] pointed out in [alda-lang/alda-core

1.3.4 (2020-03-14)

• Fixed a minor bug where the parser would fail to recognize that a note at the end of a part that ends with a ~ followed by a | is supposed to be slurred.

  In other words, it was treating c4~ | at the end of an instrument part as an un-slurred note, when it's supposed to be slurred.

• Fixed buggy error handling logic in the case of an unhandled exception. Before, we were inadvertently hiding the exception and the message ended up being "null." Now the exception message gets through.

1.3.3 (2019-08-16)

• New alda.lisp function, midi-note, is available as an alternative to pitch that is occasionally useful for algorithmic compositions, etc. For example, instead of (note (pitch :c :sharp)), you can specify the MIDI note number, (note (midi-note 61)).

1.3.2 (2019-06-26)

• To help debug alda-client-java issue #38, we will now print the exit code baked into an AldaException whenever one is thrown.

1.3.1 (2019-05-05)

• Tabs can now be used as whitespace in an Alda score.

• Fixed a bug where attempting to play an empty score (e.g. c d e, which results in an empty score because there are no instruments) results in a NullPointerException.

  The problem was that there were no instruments, so the MIDI system wasn't being set up. However, we expect the MIDI system to be set up even if there are no instruments and no notes to play, because we use the MIDI Sequencer to schedule notes.

1.3.0 (2019-04-14)

• New CLI command: alda export and REPL command: :export

  This command exports an Alda score to another format. Currently, the only supported format is MIDI. MIDI files are exported at a resolution of 128 pulses per quarter note (PPQ).

  The score is provided in the same way as it is for alda play and alda parse: by specifying either a -f / --file, a string of -c / --code, or piping in the code via STDIN.

  alda export -f my-score.alda -o my-score.alda
  alda export -c 'piano: c8 d e f' -o piano-notes.mid
  echo 'piano: c8 d e f' | alda export -o piano-notes.mid
  

  The :export REPL command takes a single argument, the output filename:

  > :export /path/to/desired-filename.mid
  

• The alda parse JSON output has a couple of new keys: tempo/values and tempo/role. These values are used internally to schedule MIDI notes in a way that is exportable.

1.2.0 (2019-01-19)

• New CLI command: alda instruments and REPL command: :instruments

  This new command lists all available instruments, which is currently the 128 instruments in the General MIDI spec, as well as midi-percussion.

  NB: Alda does have a number of aliases for these instruments, e.g. piano is recognized as midi-acoustic-grand-piano. These aliases are not included in the list.

• Made adjustments to the command that prints for Windows users when running alda update to update the Alda client.

  For details, see issue #35.

1.1.0 (2018-12-01)

New feature alert!

An "alternate ending"-like feature has been added to the Alda language. The syntax looks like this:

piano:
  [ c8 d e f
    [g f e4]'1-3
    [g a b > c4.]'4
  ]*4

This allows you to have repeated phrases that can differ on each iteration. In the example above, each repeat starts with c8 d e f; on times 1 through 3 through the repeated phrase, the phrase ends with g f e4, whereas on the 4th time through, the phrase ends with g a b > c4..

Note that these "adjustments" can occur anywhere within the repeated phrase, not necessarily at the end, making this feature of Alda more flexible than the "alternate endings" notation seen in sheet music. To illustrate this, here is another example where the phrase has what you might describe as an "alternate beginning" and an "alternate middle":

piano:
  [ [c8 d e]'1,3 [e8 d c]'1,3
    f
    [g f e]'1-3 [g a b]'4
    > c <
  ]*4

Thanks to @elyisgreat for the initial idea/discussion and @pzxwang for implementing the feature! :balloon:

1.0.1 (2018-11-24)

Whoops! It turns out that the mechanism we had in place in the Alda client for determining whether or not your version of Alda is up-to-date had a flaw that prevents one from updating from Alda 1.0.0-rcXX to Alda 1.0.0!

That's fixed in this version. Also, your client will be able to update to the latest version now because now the latest version is 1.0.1 instead of 1.0.0. :)

1.0.0 (2018-11-24)

This release is functionally equivalent to the previous release, 1.0.0-rc85. After 3 years of working on a series of 1.0.0 release candidates, the focus has shifted toward re-architecting Alda in a way that will allow us to make some substantial improvements. The result of this restructuring will become a new major version of Alda, version 2.0.0.

The work has only just started on Alda 2.0.0, and it will probably be a long while before the initial release in the 2.0.0 series. We will continue to maintain the 1.0.0 series in the meantime. As such, it feels like now is as good a time as any to release Alda 1.0.0!

1.0.0-rc85 (2018-10-28)

• Made internal improvements to the Alda sound engine. Specifically, the sound engine now uses a Java MIDI Sequencer to schedule and play MIDI notes, whereas before we were using a third party library called JSyn.

  You shouldn't notice any difference in note scheduling, but if you do notice any problems, please file an issue in the alda-sound-engine-clj repo so that we can address them!

• The schedule function has been removed from alda.lisp. Scheduled functions haven't been very useful since we moved to a client/server architecture, and we haven't implemented a way for them to work with the new changes to the sound engine. So, we are removing the feature for now. We may re-implement the scheduled functions feature in the future, in a way that works with both the client/server architecture and the current implementation of the sound engine.

  For more context on this, see alda-core#65.

1.0.0-rc84 (2018-08-25)

• Handled an edge case re: what to display when playing extremely short scores.

• Improved the help text descriptions of the :info and :save REPL commands.

1.0.0-rc83 (2018-08-25)

• Implemented a --no-color CLI option, which suppresses ANSI color codes.

1.0.0-rc82 (2018-07-01)

• Upgraded JLine dependency to 2.14.6 to fix the platform-specific "Failed to construct terminal" part of this issue.

1.0.0-rc81 (2018-03-08)

• Added an :info command to the Alda REPL. It prints some user-readable information about the current score, for example:

  p> :info
  Instruments: piano-sFz6g
  Current instruments: piano-sFz6g
  Events: 6
  Markers: start, one, two, three
  

  Thanks, [TBuc], for implementing this new feature!

1.0.0-rc80 (2018-02-28)

• Fixed a minor bug in the parser: there was an edge case where a "get variable" event wasn't being disambiguated from its earlier, less-specific "name" form if the "get variable" event happened to be the last thing in the definition of another variable.

  Thanks to @elyisgreat for spotting the bug!

1.0.0-rc79 (2018-02-16)

• Fixed a minor bug in the parser that is only evident when using the alda parse command. The bug was that in certain situations where the code is syntactically valid, but there is an error at score build time (e.g. piano: undefined where a variable is referenced that has not been defined), the parser was returning nil instead of throwing an error.

1.0.0-rc78 (2018-02-05)

• Fixed a bug where the parser did not correctly parse nested events in some situations, for example a set-variable expression containing a CRAM expression containing a chord.

  Thanks to [elyisgreat] for reporting this issue!

1.0.0-rc77 (2018-02-03)

• On Windows, Alda processes would show up in Task Manager as "A music programming language for musicians" due to confusion on my part (as a non-Windows user) about the properties of a Windows executable. Now they ought to show up as "Alda" so you can easily identify them.

• Fixed a bug in the Alda REPL where the :play from and to options were being completely ignored.

• Fixed a separate bug where the --from command-line option to alda play was being ignored.

• Fixed issues where ! is not escaped properly in the Alda REPL.

  This is something that had been fixed previously in the Clojure version of the Alda REPL, but not ported over when we rewrote the REPL as part of the Java client.

  For context, see this issue.

• Enabled persistent history for the Alda REPL. For example, if you start a REPL session and enter a bunch of lines of input, then close the session and start a new one, you can access the lines you typed in the previous session by pressing the Up arrow.

  History is stored in a file at ~/.alda-repl-history.

1.0.0-rc76 (2017-10-30)

• Fixed a bug in the way the program path is determined when a server starts workers. (That code lives in alda.util, in this repo.) The bug was showing itself when the path to the alda (or alda.exe) executable contained spaces or other special characters. This was causing the worker processes not to start in environments where the path to alda (or alda.exe) contains spaces.

  Thanks to @Hemaolle for the detective work and PR to fix this issue!

1.0.0-rc75 (2017-10-17)

• Added a reference-pitch (alias: tuning-constant) attribute, which will have an affect on the pitch of each note in Hz. This number is the desired pitch of A4 (the note A in the 4th octave). The default value is 440 Hz.

  However, please note that this value is not currently used. We are still figuring out how to tune MIDI notes in Java -- it is more difficult that one might expect. If you're interested in helping with this, please let us know!

• Added a transposition (alias: transpose) attribute, which moves all notes (either per-instrument, or globally, depending on whether you are using transpose or transpose!) up or down by a desired number of semitones. Positive numbers represent increasing semitones, and negative numbers represent decreasing semitones.

  This attribute can be used to make writing parts for transposing instruments more convenient. To see transpose in use, see this example score, a transcription of a saxophone quartet by Juan Santiago Jiménez.

  Saxophones are transposing instruments; soprano and tenor saxophones are considered "Bb" instruments, and alto and baritone saxophones are considered "Eb" instruments. This means that an instrument part written for a baritone saxophone, for example, might appear to be written in C major, but when read and performed by a baritone saxophonist, it will sound like Eb major, the intended key.

Thanks, [pzxwang], for implementing these new features!

1.0.0-rc74 (2017-10-14)

• Minor improvement to the new tempo function overload and metric-modulation function: the supplied note-length can be a string representing multiple note lengths tied together, e.g.:

  (tempo "4~16" 120)
  

  Thanks to [elyisgreat] for the issue and [pzxwang] for the pull request!

• Fixed a strange issue in the client where, after updating Alda successfully, a java.lang.NoClassDefFoundError would be printed.

1.0.0-rc73 (2017-10-12)

• Improved the timing of waiting for the server to stop before starting a new one when running the alda downup command.

  Before, this was just guesswork, and often times, the server wouldn't be down yet, so when a new server tried to start, it would fail with the message:

  There is already a server trying to start on this port. Please be patient -- this can take a while.
  

  Now, we're actually checking to see when the server stops responding, and waiting until that's the case before we try to start a new server.

  Unfortunately, there is still a bit of guesswork here because the message above is triggered by (assuming you're running OS X or Linux) a check to see if there is an Alda server process in your OS that was started on the same port you are trying to use. There is still a brief window of time between when the server stops responding to requests and when the process has terminated.

  As such, I think there is room for improvement in the future, and you might still see the message above from time to time. But, with this release, things should at least be better than they were before.

• Expanded the scope of the -t / --timeout option to include how long (in seconds) the Alda command-line client should wait, after running alda down or alda downup, for confirmation that the server has gone down. The default value is still 30 seconds, which should be more than enough time on most systems.

1.0.0-rc72 (2017-10-09)

• Added an overload of tempo that allows you to specify the tempo in terms of a note value other than (the default) a quarter note.

  For example, "♩. = 150" can be expressed as:

  (tempo! "4." 150)
  

  (NB: the note value can be either a number or a string containing a number followed by dots.)

  It is still OK to leave out the note value; the default behavior is to set the tempo relative to a quarter note. "♩ = 60" can still be expressed as:

  (tempo! 60)
  

• Added a new function, metric-modulation, which sets the tempo based on a metric modulation, i.e. shifting from one meter to another.

  Say, for example, that you're writing a score that starts in 9/8 -- three beats per measure, where each beat is a dotted quarter note.

  At a certain point in the piece, you want to transition into a 3/2 section -- still three beats per measure, but now each beat is a half note. You want the "pulse" to stay the same, but now each beat is subdivided into 4 half notes instead of 3. How do you do it?

  In traditional notation, it is common to see annotations like "♩. = 𝅗𝅥 " at the moment in the score where the time signature changes. This signifies that at that moment, the pulse stays the same, but the amount of time that used to represent a dotted quarter note now represents a half note. When the orchestra arrives at this point in the score, the conductor continues to conduct at the same "speed," but each musician mentally adjusts his/her perception of how to read his/her part, mentally subdividing each beat into 4 eighth notes instead of 3 eighth notes.

  In Alda, you can now express a metric modulation like "♩. = 𝅗𝅥 " as:

  (metric-modulation! "4." 2)
  

Thanks, [pzxwang], for the PR to add these new features!

1.0.0-rc71 (2017-10-07)

• Added an --output (-o) option to the alda parse command that allows you to specify what should be output. Valid values are:

  • data (default) is the map of score data that includes instruments, events, etc.

  • events is the sequence of events parsed from the score.

  For example (using [jq][jq] to pretty-print the JSON for readability):

  # score data output
  $ alda parse -c 'piano: c d e' | jq .
  
  {
    "chord-mode": false,
    "current-instruments": [
      "piano-cnLzW"
    ],
    "events": [
      {
        "offset": 500,
        "instrument": "piano-cnLzW",
        "volume": 1,
        "track-volume": 0.7874015748031497,
        "panning": 0.5,
        "midi-note": 62,
        "pitch": 293.6647679174076,
        "duration": 450,
        "voice": null
      },
      {
        "offset": 0,
        "instrument": "piano-cnLzW",
        "volume": 1,
        "track-volume": 0.7874015748031497,
        "panning": 0.5,
        "midi-note": 60,
        "pitch": 261.6255653005986,
        "duration": 450,
        "voice": null
      },
      {
        "offset": 1000,
        "instrument": "piano-cnLzW",
        "volume": 1,
        "track-volume": 0.7874015748031497,
        "panning": 0.5,
        "midi-note": 64,
        "pitch": 329.6275569128699,
        "duration": 450,
        "voice": null
      }
    ],
    "beats-tally": null,
    "instruments": {
      "piano-cnLzW": {
        "octave": 4,
        "current-offset": {
          "offset": 1500
        },
        "key-signature": {},
        "config": {
          "type": "midi",
          "patch": 1
        },
        "duration": {
          "beats": 1,
          "ms": null
        },
        "min-duration": null,
        "volume": 1,
        "last-offset": {
          "offset": 1000
        },
        "id": "piano-cnLzW",
        "quantization": 0.9,
        "duration-inside-cram": null,
        "tempo": 120,
        "panning": 0.5,
        "current-marker": "start",
        "time-scaling": 1,
        "stock": "midi-acoustic-grand-piano",
        "track-volume": 0.7874015748031497
      }
    },
    "markers": {
      "start": 0
    },
    "cram-level": 0,
    "global-attributes": {},
    "nicknames": {},
    "beats-tally-default": null
  }
  

  # events output
  $ alda parse -c 'piano: c d e' -o events | jq .
  
  [
    {
      "event-type": "part",
      "instrument-call": {
        "names": [
          "piano"
        ]
      },
      "events": null
    },
    {
      "event-type": "note",
      "letter": "c",
      "accidentals": [],
      "beats": null,
      "ms": null,
      "slur?": null
    },
    {
      "event-type": "note",
      "letter": "d",
      "accidentals": [],
      "beats": null,
      "ms": null,
      "slur?": null
    },
    {
      "event-type": "note",
      "letter": "e",
      "accidentals": [],
      "beats": null,
      "ms": null,
      "slur?": null
    }
  ]
  

The new "events" output mode can be useful for debugging Alda code that isn't behaving as expected.