CLI tool
alda-lang/alda avatar
alda-lang/alda

Alda: A Text-Based Music Programming Language for the Command Line

A music programming language for musicians. :notes:

5,961 stars315 forksGoEPL-2.0

At a glance

What is it?
Alda lets you write scores as plain text and hear them through a command-line tool. It suits musicians who want version-controllable music and programmers who need algorithmic composition, but it is not a notation editor.
Who is it for?
Alda is worth adopting if you already live in a text editor and want scores you can diff, script and generate programmatically; the examples directory gives you real scores to learn from. It is the wrong tool if you need engraved notation, MusicXML interchange today, or a graphical piano roll, because export to MusicXML is listed as planned rather than shipped.
Can I use it commercially?
Yes, with conditions. EPL-2.0 is a weak copyleft licence: you can use it inside commercial and closed-source software, but if you distribute changes to its own files, you must publish those changes under the same licence.
Is it still maintained?
Yes. The repository last received commits 23 days ago.
What is it written in?
Mainly Go, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • alda-lang/alda5,961 ★ · +15
Star history
Repository2026-09-232026-11-15
alda-lang/alda5.9k6k

15 Stars in the last 53 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

What Alda Is and the Problem It Solves

Alda is a text-based programming language for music composition. The README describes it as letting you compose and play back music using only your text editor and the command line. That single sentence captures the trade: you give up the mouse-driven score editor and get a file that behaves like source code.

The audience is stated in the README, and the phrasing is unusually direct. Alda is designed for musicians who don't know how to program, as well as programmers who don't know how to music. Most music software picks one of those groups. A DAW assumes you understand audio routing and clip editing. A library like SuperCollider assumes you can write code. Alda's syntax sits between them: instrument names, octave markers and note letters with duration suffixes.

The pitch example in the README shows the shape of it. A part begins with an instrument name followed by a colon, then an octave setting, then notes. Durations are attached as digits, so g8 is an eighth note and g4 is a quarter. Octave shifts use angle brackets, and the pipe character separates measures. None of that requires a compiler background, and none of it requires knowing what a DAW track is.

Where this pays off is anything that benefits from being a file. A score can be committed, reviewed in a diff, generated by a script, or parameterized. The README explicitly lists writing music programmatically for algorithmic composition and live coding as a supported use. That is the real dividing line: if your music needs to be produced by a process, text is the right representation.

How the Client and Player Fit Together

Alda is not one program. The README states that it consists of two components: the client, written in Go, and the player, written in Kotlin/Java. That split is the most important architectural fact for anyone evaluating the project, because it determines what you have to have installed and what can fail independently.

The client is what you invoke as alda. It parses your score and talks to the player. The player is the part that actually turns the parsed score into sound, rendering MIDI using instruments from the General MIDI Sound Set. The two are separate executables built from separate directories in the repository, client/ and player/.

The practical consequence is that the player is a JVM component. If you build from source, you are building a Go binary and a Kotlin/Java artifact, and the build instructions are two separate commands rather than one. The README points to client/README.md and player/README.md for details beyond the top-level build steps, which is a signal that the two halves have their own requirements and their own documentation surface.

Data flows one way in normal use: you write text, the client parses it, the player renders it. The interactive REPL changes the timing of that flow but not the direction. According to the README, the REPL lets you enter Alda code and hear the results in real time. That is the mode where the architecture is most visible, and also the mode where a player that fails to start will be most obvious.

Installing Alda and Playing Your First Score

The README does not give install commands for a released binary. It says to see the official website at alda.io/install for instructions to install the latest release. That is the path most users should take.

If you would rather build from source, the README gives the steps. Note that this builds both halves, and the executables land in client/target and player/target.

bash
# Clone the repo
git clone https://github.com/alda-lang/alda.git
cd alda

# Build the client and player executables
client/bin/build
player/bin/build

The README states that the output of the build commands shows you the path to the built executables, and that those include builds for various OS/arch combinations. Read that output rather than assuming a fixed path.

Once alda is on your PATH, the README's demo section gives three ways to use it. The first is discovering what the tool offers:

bash
alda --help

The second plays a file. The repository ships an examples/ directory, and the README uses a Bach cello suite as its example:

bash
alda play --file examples/bach_cello_suite_no_1.alda

The third plays code you type directly, without creating a file first. This is the fastest way to check that the player is producing sound:

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

If you want to work iteratively, the README documents an interactive session:

bash
alda repl

The REPL is documented separately in doc/alda-repl.md. For learning the language itself, the examples/ directory is the most useful resource the repository ships; it contains scores ranging from hello_world.alda to a Rachmaninoff piano concerto movement, plus files that demonstrate specific features such as dynamics, panning, polyphony, percussion, key signatures and MIDI channel management.

Where Alda Stops Being the Right Tool

The clearest limitation is stated by the project itself, in its own planned-features list. Export to MusicXML is listed as planned, with a link to a discussion rather than a shipped feature. MusicXML is the interchange format that most notation software reads and writes. Until that lands, an Alda score is not portable into a notation editor, and that is a real boundary rather than a minor gap.

The same planned list includes running Alda in the browser and defining waveform synthesis instruments. Both are absent today. The synthesis item matters if you were hoping to design your own sounds: the README describes creating MIDI music using instruments from the General MIDI Sound Set, which is a fixed palette. If your work depends on a custom timbre, the documented path does not exist yet.

Raspberry Pi support is also on the planned list, described as needing improvement. Treat that as a warning if the Pi is your target platform rather than a supported configuration.

There is a subtler cost that follows from the two-component design. A Go client plus a JVM player means two runtimes to keep working, and the failure modes are not symmetric. A player that cannot start, or that cannot reach your audio output, is a different class of problem, and the README does not document rollback or recovery steps for either. The README is also silent on what happens when a score references an instrument outside the General MIDI set.

Finally, consider what you are giving up by choosing text at all. If your workflow is built around seeing notation while you write, Alda asks you to hold the score in your head or render it elsewhere. The README links a blog post on why to compose this way instead of in a graphical sheet music notation program.

Alda Against Algorithmic Composition Environments

The obvious comparison is with code-based music environments such as SuperCollider, and the difference is in what each one treats as the primitive. Alda's primitives are musical: instrument, note, octave, duration, measure. Its documented output path is MIDI through the General MIDI Sound Set. You describe a score and the player renders it.

SuperCollider's primitives are signal-processing: oscillators, filters, envelopes, buses. You describe a synthesis graph and it runs on a server. That is why the two projects appear in the same conversations about algorithmic music composition software despite sharing almost no surface area. If you want to build a sound from an oscillator up, Alda's documented feature set does not reach that layer; waveform synthesis instruments are on the planned list. If you want to write a melody quickly in a file that reads like a score, SuperCollider makes you assemble more machinery first.

The same distinction applies against notation-first tools. A notation editor gives you immediate visual feedback and exports formats other software reads. Alda gives you a diffable text file and a command line, and MusicXML export is not there yet. The README links to a blog post for the rationale behind choosing text, which is worth reading before deciding, because the argument is about workflow rather than about capability.

One more comparison is worth naming: Faust is a functional language for signal processing and plugin development, aimed at building DSP that runs as a VST or similar. Alda is aimed at composing and playing back scores. They are not substitutes, and treating Faust as an Alda alternative will send you down the wrong path.

Maintenance, Licensing and Upgrade Cost

The repository is not archived, and the last push was on 2026-10-23. That is recent enough that the project is not dormant, and the presence of a CHANGELOG.md plus separate CHANGELOG-0.X.X.md and CHANGELOG-1.X.X.md files indicates a versioned release history with a major-version boundary already crossed.

Upgrade cost is hard to estimate from the README alone, and that is worth saying plainly. The repository has no published GitHub releases, so there is no version number or release note to read. The VERSION file at the repository root is the authoritative place to check what you are running, and the changelog files are where breaking changes would be recorded. If you are pinning Alda in a build pipeline, read the 1.X.X changelog before moving across a major version.

The two-component design adds an upgrade dimension that single-binary tools do not have. Client and player are built separately and can in principle be versioned or replaced separately, so an upgrade means checking both. The README does not document a compatibility matrix between client and player versions, which is a gap if you plan to upgrade one without the other.

On licensing: Alda is distributed under the Eclipse Public License version 2.0, per the README's license section, with copyright attributed to Dave Yarwood et al. EPL-2.0 is a copyleft licence with a weaker scope than the GPL, and it includes a patent grant. What that means for your specific product is a question for your own counsel; the relevant fact here is simply that the licence is EPL-2.0 and not a permissive MIT or Apache licence, so the obligations differ from what many Go and JavaScript developers assume by default.

Editorial conclusion

Alda is worth adopting if you already live in a text editor and want scores you can diff, script and generate programmatically; the examples directory gives you real scores to learn from. It is the wrong tool if you need engraved notation, MusicXML interchange today, or a graphical piano roll, because export to MusicXML is listed as planned rather than shipped. Before committing, verify that the player starts on your machine, that your sound output is configured, and that the General MIDI instruments you need are covered.

Frequently asked questions

How do I install Alda?

The README does not list install commands for a released binary. It directs you to the official website at alda.io/install for instructions to install the latest release. Building from source is the documented alternative, using client/bin/build and player/bin/build.

What can I do with the alda command-line tool?

The README's demo section shows four uses: alda --help for commands and options, alda play --file to play a score file, alda play --code to play code typed at the command line, and alda repl to start an interactive session that plays results in real time.

Does Alda export to MusicXML?

Not according to the README. Export to MusicXML for interoperability with other music software appears in the planned features list with a link to a discussion, not among the features the project currently ships.

What instruments can Alda play?

The README states that Alda can create MIDI music using any of the instruments in the General MIDI Sound Set. Defining your own waveform synthesis instruments is listed as a planned feature rather than a current one.

What is Alda written in?

The repository lists Go as the primary language, and the README explains that Alda consists of two components: the client, written in Go, and the player, written in Kotlin/Java.

Official sources

  1. alda-lang/alda on GitHub
  2. Issues
  3. License: EPL-2.0
  4. Project website
  5. README
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/alda-lang-alda.svg)](https://hysenlabs.com/projects/alda-lang-alda)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/alda-lang-alda.svg)](https://hysenlabs.com/projects/alda-lang-alda)

Was this useful?