A music programming language for musicians. :notes:

Overview

alda logo

Installation | Docs | Changelog | Contributing

Join us on Slack! composers chatting

Alda is a text-based programming language for music composition. It allows you to compose and play back music using only your text editor and the command line.

piano:
  o3
  g8 a b > c d e f+ g | a b > c d e f+ g4
  g8 f+ e d c < b a g | f+ e d c < b a g4
  << g1/>g/>g/b/>d/g

For more examples, see these example scores.

The language's design equally favors aesthetics, flexibility and ease of use.

(Why compose music this way instead of in a graphical sheet music notation program? See this blog post for a brief history and rationale.)

Features

  • Easy to understand, markup-like syntax.
  • Designed for musicians who don't know how to program, as well as programmers who don't know how to music.
  • A score is a text file that can be played using the alda command-line tool.
  • Interactive REPL lets you enter Alda code and hear the results in real time.
  • Supports writing music programmatically (for algorithmic composition, live coding, etc.)
  • Create MIDI music using any of the instruments in the General MIDI Sound Set

TODO

If you'd like to help, come on in -- the water's fine!

Installation

See the official website for instructions to install the latest release of Alda.

Demo

First start the Alda server (this may take a minute):

alda up

To play a file containing Alda code:

alda play --file examples/bach_cello_suite_no_1.alda

To play arbitrary code at the command line:

alda play --code "piano: c6 d12 e6 g12~4"

To start an Alda REPL:

alda repl

Documentation

Alda's documentation can be found here.

Contributing

We'd love your help -- Pull Requests welcome!

The Alda project is composed of a number of subprojects, each of which has its own GitHub repository within the alda-lang organization.

For a top-level overview of things we're talking about and working on across all of the subprojects, check out the Alda GitHub Project board.

For more details on how you can contribute to Alda, see CONTRIBUTING.md.

Another way you can contribute is by sponsoring Dave in the future development of Alda.

Support, Discussion, Camaraderie

Slack: Joining the Alda Slack group is quick and painless. Come say hi!

Reddit: Subscribe to the /r/alda subreddit, where you can discuss all things Alda and share your Alda scores!

License

Copyright © 2012-2021 Dave Yarwood et al

Distributed under the Eclipse Public License version 1.0.

Issues
  • Alda not starting workers in some cases

    Alda not starting workers in some cases

    Forked from the comments of https://github.com/alda-lang/alda/issues/266#issuecomment-248302194

    Since upgrading to rc41 from rc31, alda doesn't spawn workers on my windows machine:

    λ alda up
    [27713] Starting Alda server...
    [27713] Server up ?
    [27713] Starting worker processes...
    [ this hangs, I waited for 5 minutes ]
    ^C
    
    λ alda status
    [27713] Server up (0/2 workers available)
    
    bug 
    opened by 0atman 60
  • Improve instance/group assignment +

    Improve instance/group assignment + "." group-member operator

    Consider the following code:

    piano:
    piano "piano1":
    
    piano: o4 c d e f g a b > c
    piano1: o4 e f g a b > c d e
    

    When played, it plays normally. However, if I switch the declaration of the instruments at the top

    piano "piano1":
    piano:
    
    piano: o4 c d e f g a b > c
    piano1: o4 e f g a b > c d e
    

    piano1 does not start playing until piano has finished its melody. The order of the melodies at the bottom does not matter, so

    piano "piano1":
    piano:
    
    piano1: o4 e f g a b > c d e
    piano: o4 c d e f g a b > c
    

    will play piano1 first and then play piano.

    And if they're both named, there is no problem. both of the scores below play normally.

    piano "piano1":
    piano "piano2":
    
    piano1: o4 c d e f g a b > c
    piano2: o4 e f g a b > c d e
    
    piano "piano2":
    piano "piano1":
    
    piano1: o4 c d e f g a b > c
    piano2: o4 e f g a b > c d e
    
    low-hanging fruit 
    opened by elyisgreat 60
  • Javascript implementation of REPL + Web Audio API

    Javascript implementation of REPL + Web Audio API

    I am loosely aware of the ability, via clojurescript, to get clojure running in native javascript. If it's possible for the parser to be ported to javascript I would be happy to build the website that surrounds it and plug in the web audio API so folks can aldajam in the browser.

    Any idea what would be involved in porting the parser to JS?

    opened by kylestetz 36
  • Refining variables

    Refining variables

    I noticed that variables were finally implemented in the latest release of alda. However with the new note spacing rules I find that writing is much more restrictive. Thus, I suggest a literal for variables; that way the note spacing rules can be more relaxed, however variables would still be clearly marked. A single quote literal '<variable>' is a possibility, as well as having something like a character before a variable '<variable> to indicate that it is one (similar to markers), however I would like to hear other suggestions.

    enhancement 
    opened by elyisgreat 35
  • Refine and document Alda installation/usage on Windows

    Refine and document Alda installation/usage on Windows

    A large handful of people have noted experiencing problems installing and running Alda in a Windows environment. #47 is a good example of an error that at least 2 other people have noted running into.

    Open questions:

    • Is it possible to run a standalone executable Boot script in Windows?

      The alda executable does start with #!/usr/bin/env boot. On OS X, I am able to run alda globally by making this file executable and copying it a directory in my $PATH. I am also able to run it by running boot ~/Code/alda/bin/alda. I can reproduce the "No such task (alda)" issue by cd-ing into ~/Code/alda/bin and trying to run boot alda, probably because Boot can't know if alda is supposed to be a task or a file. Clarifying that it's a file by running boot ./alda fixes it.

    • Can a Windows user simply copy the alda executable script into a directory in their path and be able to run alda from any directory?

      Subquestion: Does a file need to be a .exe in order to be added to the path?

    • Why doesn't running boot D:\path\to\alda (with boot.exe on the user's path) work?

      ... Does it work?

    Would greatly appreciate any insight from Windows power users, or better yet, Windows users familiar with running Boot. I am a Windows n00b.

    documentation 
    opened by daveyarwood 33
  • Massive CPU usage

    Massive CPU usage

    I tried the latest version of alda today (alda update), and found that running alda up maxed out my machine's CPU and basically locked it up with loadaverages over 80(!).

    Here are the offending threads:

    2016-09-16-132039_2020x123_scrot

    What's happened in the last 10 days? My machine is very powerful, and more importantly didn't used to have this problem.

    My version:

    $ alda repl
    Sep 16, 2016 1:25:00 PM com.jsyn.engine.SynthesisEngine start
    INFO: Pure Java JSyn from www.softsynth.com, rate = 44100, RT, V16.7.3 (build 457, 2014-12-25)
    Preparing MIDI system... done.
    
     █████╗ ██╗     ██████╗  █████╗ 
    ██╔══██╗██║     ██╔══██╗██╔══██╗
    ███████║██║     ██║  ██║███████║
    ██╔══██║██║     ██║  ██║██╔══██║
    ██║  ██║███████╗██████╔╝██║  ██║
    ╚═╝  ╚═╝╚══════╝╚═════╝ ╚═╝  ╚═╝
    
                v1.0.0-rc38
             repl session
    

    My machine:

    $ uname -a
    Linux T420 4.7.2-1-ARCH #1 SMP PREEMPT Sat Aug 20 23:02:56 CEST 2016 x86_64 GNU/Linux
    

    My jvm:

    $ java -version
    java version "1.8.0_102"
    Java(TM) SE Runtime Environment (build 1.8.0_102-b14)
    Java HotSpot(TM) 64-Bit Server VM (build 25.102-b14, mixed mode)
    
    bug 
    opened by 0atman 29
  • Implement [C]razy [R]hythm [A]lda [M]agic

    Implement [C]razy [R]hythm [A]lda [M]agic

    Closes #9

    feature 
    opened by crisptrutski 24
  • MIDI audio is delayed after suspending the server

    MIDI audio is delayed after suspending the server

    I get pretty much immediate responses from the server* after first running it, but after leaving the server running for a while (e.g. if I leave my computer and come back hours later), it may take several seconds or more before I hear anything. Restarting the server fixes it.

    *meaning, if I run alda play -r -c 'piano: c', I hear the note immediately

    No idea what the issue is at this point, but figured I would report it in case anyone has any ideas.

    bug 
    opened by daveyarwood 23
  • Inline Clojure code

    Inline Clojure code

    Closes #94.

    This introduces a major change to alda.parser -- anything between parentheses is now interpreted as a Clojure expression and evaluated with the help of a custom reader that will attempt to resolve symbols in the alda.lisp namespace whenever possible. There is also some regex hackery that allows things like (volume 50, tempo 120) to still work by splitting on commas and semicolons (intelligently*) and turning them into separate S-expressions like (do (volume 50) (tempo 120)).

    *Commas and semicolons inside strings and as character literals still function as they normally do in Clojure.

    As a side effect of this, (* the old (and not so great) long comment syntax *) had to be deprecated. R.I.P.

    For full backwards compatibility, I've also extended the defattribute macro so that it defines more functions for use in the alda.lisp namespace (and by extension, in Alda code) -- you can now call any alias of an attribute as a function (e.g. (vol 50) instead of having to do (set-attribute :vol 50)), and you can set global attributes by appending a ! after the function name (e.g. (vol! 50) instead of (global-attribute :vol 50))


    I also happened to notice a bug with the :play function not fully resetting instruments' attributes (octave, volume, etc.) before playing a score from the beginning, leading to inconsistent playback. I'm including a fix for that in this PR as well.

    feature 
    opened by daveyarwood 23
  • Support

    Support "from" and "to" for playing

    Not quite done with this yet, but perhaps ready for feedback.

    There are some performance-oriented things here, like making some functions lazy, a lower-overhead trick than (doall (pmap ..)) and using transducers in some places.

    Will be back this evening to finish this off - supporting labels, typing in with CLI and REPL commands, and adding tests

    feature 
    opened by crisptrutski 22
  • #321 Validate MIDI note range

    #321 Validate MIDI note range

    Added validation for midi note range in note.go. We raise a UserFacingError if midi note is > 0 or < 127 and log the event.

    opened by KartikYZ 1
  • Alda Processes are not independent of the shell

    Alda Processes are not independent of the shell

    I'm not sure if this is a universal problem or one that only affects Windows cmd and powershell. It seems that alda processes are not independent of the shell anymore, since if alda is doing something such as play a score from a file or open a REPL and I try and close the shell, it doesn't seem to let me right away.

    I think the problem is best illustrated in the below recordings:

    https://user-images.githubusercontent.com/8622264/138393978-8fb3b9a0-fb86-4c54-802a-cd998c02409c.mp4

    (PowerShell)

    https://user-images.githubusercontent.com/8622264/138393990-6afd4066-06a9-4679-bd1d-7a13341c9a77.mp4

    (Cmd)

    Checking the task manager reveals that when I, say, play a score, the player processes are children of the shell:

    Screenshot (23)

    bug windows 
    opened by elyisgreat 1
  • CLI output is wonky

    CLI output is wonky

    🐞 Bug report 🐞

    Description

    I'll let the below image speak for itself:

    Screenshot (22)

    Running the REPL causes PowerShell to recolour the screen in a weird way. Running this on cmd doesn't cause any recolouring, but you still get these ←[0m and ←[36m strings appearing.

    bug low-hanging fruit 
    opened by elyisgreat 9
  • REPL :stop command fails for overly long segments

    REPL :stop command fails for overly long segments

    🐞 Bug report 🐞

    Description

    The REPL :stop command simply fails to function when an overly long segment is played. More specifically, the :stop command simply fails after the first 2 seconds for certain sufficiently long segments (usually around 45 seconds or longer). Quitting the repl and issuing an alda stop or alda shutdown command seems to be the only way to stop the playback.

    Steps to Reproduce

    1. Run the alda repl
    2. Enter piano: c*100 into the repl
    3. Wait for a couple of seconds. After the first four or five notes, issue a :stop command.

    Expected Behavior

    The segment stops playing.

    Actual Behavior

    The segment fails to stop playing.

    Environment

    Windows 10, PowerShell, alda 2.0.6

    bug 
    opened by elyisgreat 1
  • Alda on Raspberry Pi

    Alda on Raspberry Pi

    Continuing from conversations in the Alda Slack group, tracking the work to be done here:

    • [x] Add ARM builds to client/bin/build
    • [ ] Tune JVM options so that alda-player processes use less memory?
    • [ ] Add arm64 release testing to CircleCI build (looks like they don't support 32-bit ARM, so can't test ARM 7)
    • [ ] Update Alda API to include arm-7 and arm64 releases
    • [ ] Ensure that alda update can find the right releases for ARM 7, arm64
    • [ ] Ensure that ARM releases are included at alda.io/install
    feature 
    opened by daveyarwood 0
  • Build instruction in main readme.md

    Build instruction in main readme.md

    🔧 Feature request 🔧

    First of all - I love Alda and I just can't express how great this project is. I would like to thank the creators and everyone involved.

    I just just would like to point out a minor documentation issue. I've found myself that running Alda requires studying the structure of this program, some aspects of this may be confusing, especially for a Raspberry Pi user who is unfamiliar with Kotlin and Go.

    Description

    I think that it may be useful to put simple build instructions in main readme.md file. It would be useful for people who use things like Raspberry Pi or maybe BSD systems.

    Examples

    1. Install OpenJDK, download Go for your system and install it.

    2. Download and unzip Alda release or clone repository.

    3. Compile player:

    cd alda-release-X.X.X/player
    ./bin/run
    

    Player binary is located in alda-release-X.X.X/player/target/X.X.X-/ 4. Compile Alda client:

    cd alda-release-X.X.X/client
    go generate
    go build
    

    Client binary will be in alda-release-X.X.X/client

    Motivation

    There are musicians out there who are not familiar with Kotlin or Go but would be happy to test Alda.

    Alternatives

    Instructions are already in player/readme.md and client/readme.md so maybe it is just enough to link these files in main readme.md

    documentation low-hanging fruit 
    opened by przem360 1
  • Repetition variations don't behave well in a sequence containing repeats

    Repetition variations don't behave well in a sequence containing repeats

    🐞 Bug report 🐞

    Description

    We are storing a single currentRepetition value (see repeat.go and repetitions.go) and using it to track the current repetition number that we are going through a repeated sequence of events.

    However, a repeated sequence can itself contain repeated events, and the nesting can be arbitrarily deep.

    I think it would probably make sense to refactor so that instead of a single "current repetition" value, we are working with a stack of "current repetition" values, where we use the topmost one and discard it when we exit the loop.

    Steps to Reproduce

    Repro case, adapted from the one @wesen provided on Slack:

    period = r16
    motif = a b c
    
    (tempo! 100)
    
    piano:
      V1: o4 [{motif}8 period period <'2 ]*4
    

    This behaves as expected. The motif is played twice in octave 4, then twice in octave 3, because on the second repetition, the "octave down" event is applied.

    period = r16
    motif = a b c
    
    (tempo! 100)
    
    piano:
      V1: o4 [{motif}8 period*2 <'2 ]*4
    

    This should behave the same, however the "octave down" event ends up getting applied on every repetition, so we play the motif in octave 4, then 3, then 2, then 1.

    Environment

    Alda version:

    $ alda version
    alda 2.0.5
    
    $ alda-player info
    alda-player 2.0.5
    log path: /home/dave/.cache/alda/logs
    
    bug 
    opened by daveyarwood 0
  • Run Alda in the browser

    Run Alda in the browser

    My primary motivation is to have a "Try It" area on the Alda website, similar to what you find on the Haskell website, where you can enter snippets of Alda code, press a "play" button and hear the result.

    There was also a request (#391) for playable demos of the example code in the Alda documentation, which I think is a great idea.

    I've been thinking about either compiling the Alda client (written in Go) to WebAssembly, or using GopherJS to compile it to JavaScript. That should allow us to parse Alda scores in the browser and hopefully send OSC messages.

    We'll also need to implement the player process (written in Kotlin) in the browser. It looks like it's possible to compile Kotlin to JavaScript, so maybe that will help. Although, I used Java inter-op quite heavily, both to use the JVM MIDI synthesizer/sequencer and to do sophisticated things with concurrency. So, I suspect that it might be challenging to try to reuse the same code base to generate a player process in JS. We might end up needing to write a port in JavaScript from scratch instead, which wouldn't be the end of the world. Ideally, we could use the same code base, though, so that we can avoid the two implementations drifting apart over time.

    feature 
    opened by daveyarwood 19
  • It would be good to have a mini player along side each snippet in documentation

    It would be good to have a mini player along side each snippet in documentation

    Something like Go playground where the user gets a small icon in the code snippet to execute the code online without installing Go. We can maybe also allow people to try out their own code.

    feature documentation 
    opened by quaintdev 1
  • Using program change number to select instrument

    Using program change number to select instrument

    🔧 Feature request 🔧

    Description

    For now we have to select instruments by saying something like midi-steel-drums: or midi-brass-section: etc., which I think is cumbersome in some situations. There are already "program change" numbers in General MIDI, it would be nice if we can also say program 1: for piano, program 12: for vibraphone, etc. (see here)

    Also, there are nine standard drum kits/sets in the General MIDI 2 specification (see here, and also Roland GS and Yamaha XG), and most MIDI equipments/general-purpose soundfonts support that. So instead of saying midi-percussion:, it would be nicer if we can say drum-kit standard:, drum-kit power: and drum-kit brush: etc. to switch to different drum kits.

    Examples

    To select piano: program 1: o4 c8 d e f g2

    To select the "Power" drum kit (which is program number 17): drum-kit power: o2 c4 e c8 c e4

    or

    drum-kit 17: o2 c4 e c8 c e4

    feature 
    opened by wiwikuan 1
Releases(1.5.0)
  • 1.5.0(Jun 30, 2021)

    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.

    Source code(tar.gz)
    Source code(zip)
    alda(7.66 MB)
    alda.exe(7.69 MB)
  • 1.4.4(Mar 6, 2021)

  • 1.4.3(Sep 29, 2020)

    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

    Source code(tar.gz)
    Source code(zip)
    alda(7.66 MB)
    alda.exe(7.68 MB)
  • 1.4.2(Jun 15, 2020)

  • 1.4.1(Apr 17, 2020)

  • 1.4.0(Mar 19, 2020)

    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

    Source code(tar.gz)
    Source code(zip)
    alda(7.79 MB)
    alda.exe(7.82 MB)
  • 1.3.4(Mar 14, 2020)

    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.

    Source code(tar.gz)
    Source code(zip)
    alda(7.79 MB)
    alda.exe(7.82 MB)
  • 1.3.3(Aug 16, 2019)

    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)).
    Source code(tar.gz)
    Source code(zip)
    alda(7.79 MB)
    alda.exe(7.81 MB)
  • 1.3.2(Jun 26, 2019)

  • 1.3.1(May 5, 2019)

    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.

    Source code(tar.gz)
    Source code(zip)
    alda(7.69 MB)
    alda.exe(7.72 MB)
  • 1.3.0(Apr 14, 2019)

    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.

    Source code(tar.gz)
    Source code(zip)
    alda(7.69 MB)
    alda.exe(7.72 MB)
  • 1.2.0(Jan 19, 2019)

    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.

    Source code(tar.gz)
    Source code(zip)
    alda(6.81 MB)
    alda.exe(6.84 MB)
  • 1.1.0(Dec 1, 2018)

    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:

    Source code(tar.gz)
    Source code(zip)
    alda(6.81 MB)
    alda.exe(6.84 MB)
  • 1.0.1(Nov 24, 2018)

    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. :)

    Source code(tar.gz)
    Source code(zip)
    alda(6.81 MB)
    alda.exe(6.83 MB)
  • 1.0.0(Nov 24, 2018)

    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!

    Source code(tar.gz)
    Source code(zip)
    alda(6.81 MB)
    alda.exe(6.84 MB)
  • 1.0.0-rc85(Oct 28, 2018)

    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.

    Source code(tar.gz)
    Source code(zip)
    alda(6.81 MB)
    alda.exe(6.84 MB)
  • 1.0.0-rc84(Aug 26, 2018)

  • 1.0.0-rc83(Aug 25, 2018)

  • 1.0.0-rc82(Jul 1, 2018)

  • 1.0.0-rc81(Mar 8, 2018)

    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!

    Source code(tar.gz)
    Source code(zip)
    alda(7.09 MB)
    alda.exe(7.11 MB)
  • 1.0.0-rc80(Feb 28, 2018)

    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!

    Source code(tar.gz)
    Source code(zip)
    alda(7.09 MB)
    alda.exe(7.11 MB)
  • 1.0.0-rc79(Feb 16, 2018)

    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.
    Source code(tar.gz)
    Source code(zip)
    alda(7.09 MB)
    alda.exe(7.11 MB)
  • 1.0.0-rc78(Feb 5, 2018)

  • 1.0.0-rc77(Feb 3, 2018)

    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.

    Source code(tar.gz)
    Source code(zip)
    alda(7.09 MB)
    alda.exe(7.11 MB)
  • 1.0.0-rc76(Oct 30, 2017)

    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!

    Source code(tar.gz)
    Source code(zip)
    alda(7.09 MB)
    alda.exe(7.11 MB)
  • 1.0.0-rc75(Oct 17, 2017)

    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!

    Source code(tar.gz)
    Source code(zip)
    alda(7.08 MB)
    alda.exe(7.11 MB)
  • 1.0.0-rc74(Oct 14, 2017)

    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.

    Source code(tar.gz)
    Source code(zip)
    alda(7.08 MB)
    alda.exe(7.11 MB)
  • 1.0.0-rc73(Oct 12, 2017)

    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.

    Source code(tar.gz)
    Source code(zip)
    alda(7.08 MB)
    alda.exe(7.11 MB)
  • 1.0.0-rc72(Oct 9, 2017)

    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!

    Source code(tar.gz)
    Source code(zip)
    alda(7.08 MB)
    alda.exe(7.11 MB)
  • 1.0.0-rc71(Oct 7, 2017)

    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.

    Source code(tar.gz)
    Source code(zip)
    alda(7.08 MB)
    alda.exe(7.11 MB)
Owner
Alda
A music programming language for musicians.
Alda
A Music programming language. Translates source code into MIDI. Includes a player. Supports MIDI-Karaoke. Includes a MIDI analyzer.

Get Started | Features | Screenshots | Programming | CLI | Contribute | License Midica is an interpreter for a Music Programming Language. It translat

Jan Trukenmüller 51 Nov 27, 2021
Esoteric Programming Language

ORCΛ Orca is an esoteric programming language designed to quickly create procedural sequencers, in which every letter of the alphabet is an operation,

Hundredrabbits 3.7k Jan 23, 2022
LilyPond mini-score engraving and sharing service for musicians.

Tunefl LilyPond mini-score engraving and sharing service for musicians. The live Tunefl service is at tunefl.com. More sleep lost by tiredpixel. Insta

Nic Williams 22 Jun 22, 2020
A language for music notation

Lydown is a language and compiler for creating music scores, parts and snippets. The lydown code is compiled to lilypond code and then compiled to PDF

Sharon Rosner 21 Apr 8, 2021
Streaming music player that finds free music for you

Desktop music player focused on streaming from free sources Links Official website Mastodon Twitter Support channel (Matrix): #nuclear:matrix.org Disc

null 7.2k Jan 16, 2022
Music player and music library manager for Linux, Windows, and macOS

Quod Libet: an audio library, manager & player Quod Libet is a cross-platform audio / music management program. It provides many ways to view your loc

Quod Libet 1.1k Jan 10, 2022
Sound Processing Language for Web Audio

CoffeeCollider CoffeeCollider is a language for real time audio synthesis and algorithmic composition in HTML5. The concept of this project is designe

mohayonao 213 Dec 18, 2021
music library manager and MusicBrainz tagger

beets Beets is the media library management system for obsessive music geeks. The purpose of beets is to get your music collection right once and for

beetbox 10.6k Jan 23, 2022
:tangerine: Clementine Music Player

Clementine Clementine is a modern music player and library organizer for Windows, Linux and macOS. Latest Release Latest Pre-Releases Website: http://

Clementine 3.1k Jan 2, 2022
Small, fast and powerful console music player for Unix-like operating systems.

Warning: cmus is not actively maintained. For details, please see #856 cmus — C* Music Player https://cmus.github.io/ Copyright © 2004-2008 Timo Hirvo

C* Music Player 4.5k Jan 16, 2022
Music player for deepin desktop environment.

deepin-music Deepin music is a local music player with beautiful design and simple functions developed by Deepin Technology. Dependencies Build depend

Wuhan Deepin Technology Co.,Ltd. 158 Jan 6, 2022
A beautiful cross platform Desktop Player for Google Play Music

Google Play Music™ Desktop Player Windows: MacOS / Linux: Run "Google Play Music" as a standalone desktop app. Never again will you have to hunt throu

Samuel Attard 8.5k Jan 21, 2022
Cross-platform music production software

LMMS A soft PR-Freeze is currently underway to prepare for refactoring (#5592). Please do not open non-essential PRs at this time. What is LMMS? LMMS

LMMS 5.5k Jan 22, 2022
Mopidy is an extensible music server written in Python

Mopidy Mopidy is an extensible music server written in Python. Mopidy plays music from local disk, Spotify, SoundCloud, Google Play Music, and more. Y

Mopidy 7.3k Jan 21, 2022
🎵 A simple, clean and cross-platform music player

Museeks A simple, clean and cross-platform music player. (museeks.io) Features Museeks aims to be a simple and easy to use music player with a clean U

Pierre de la Martinière 1.1k Jan 10, 2022
MuseScore is an open source and free music notation software. For support, contribution, bug reports, visit MuseScore.org. Fork and make pull requests!

Music notation and composition software MuseScore is an open source and free music notation software. For support, contribution, and bug reports visit

MuseScore 6.7k Jan 14, 2022
GTK 3 client for the Music Player Daemon - I'm looking for new maintainers!

Sonata is looking for new maintainers! I (@multani) don't use Sonata much anymore and as a consequence, I've been very slow to answer even to the few

Jonathan Ballet 123 Aug 28, 2021
Python library for audio and music analysis

librosa A python package for music and audio analysis. Documentation See https://librosa.org/doc/ for a complete reference manual and introductory tut

librosa 4.9k Jan 15, 2022
Ear-bending noises and music

Cecilia5 - the audio processing toolbox Cecilia is an audio signal processing environment. Cecilia lets you create your own GUI (grapher, sliders, tog

Olivier Bélanger 130 Dec 29, 2021