Live Coding Blog

What is Melrose?

Melrose is a MIDI producing environment for creating (live) music, using golang-based music programming language. It is created by a Dutch software artist named Ernest Micklei in 2020. Melrōse offers a more human-centric approach to algorithmic composition of music. It defines a new programming language and includes a tool to play music by evaluating expressions in that langage. With Melrōse, exploring patterns in music is done by creating musical objects that can be played and changed at the same time.

Melrose offers a variety of features:

– Musical objects: Create a Note, Sequence, Chord, Progression to start your musical journey.

– Operations: Apply to musical objects such Repeat, Resequence, Replace, Pitch, Fraction, Mapping to create new musical combinations.

– Playing: Play any musical object directly, or in a Loop or in a Track, alone or together with others.

– Interactive: While playing you can change any musical object by re-evaluating object definitions.

– MIDI: Send MIDI to any sound producting system such as a DAW or your hardware synthesizer. React to or record MIDI input to create new musical objects.

How is Melrose Used in the Real World?

Melrose allows composers to generate and manipulate MIDI sequences using code. It can send MIDI messages to external synths or DAWs (Digital Audio Workstations); so therefore, musicians can write scripts to trigger MIDI sequences on-the-fly. Coders and musicians can use Melrose to explore harmonies, scales, and rhythmic structures programmatically. And developers can use Melrose to generate adaptive soundtracks for games.

Impact on Music Community:

Melrose empowers coders & musicians and bridge the gap between coding and music production. It also enables complex, non-repetitive compositions, unlike traditional DAWs, it allows music to be generated with rules and randomness. Music coders can have access to a lightweight, code-driven alternative to DAWs that are not too expensive and complicated to master. Especially for education, schools and educators can utilize the tool to teach interactive and generative music composition.

Sample Code:

it = iterator(6,1,4,-1) // delta semitones
pm = pitchmap('1:0,1:7,1:12,1:15,1:19,1:24',note('c')) // six notes
sm = fraction(8,resequence('1 4 2 4 3 6 5 4',pm)) // note sequence of eights
lp_sq = loop(pitch(it,sm),next(it)) // loop the sequence and change pitch on every iteration


p = progression('d', 'ii V I')

bpm(120)
s5 = sequence('16.e 16.e 16.e 8.c 8.e 8.g 8.g3 8.c 8.g3 16.e3 16.a3 16.b3 16.a#3 16.a3 8.g3 8.e 8.g4 16.a4 16.f4 16.g 16.e 16.c 16.d 16.b 16.c')

bpm(100)  
s7 = sequence('16.f#3+ 16.f#3+ 16.d3 8.b2 8.b2 8.e3 8.e3 16.e3 16.g#3+ 16.g#3+ 16.a3 16.b3 16.a3 16.a3 16.a3 8.e3 8.d3 8.f#3 8.f#3 16.f#3 16.e3 16.e3 16.f#3 16.e3')
s8 = loop(s7)

f1 = sequence('C D E C')
f2 = sequence('E F 2G')
f3 = sequence('8G 8A 8G 8F E C')
f4 = sequence('2C 2G3 2C 2=') 

v1 = join(f1,f1,f2,f2,f3,f3,f4,f4)

kick=note('c2') // 1
clap=note('d#2') // 2
openhi=note('a#2') // 3
closehi=note('g#2') // 4
snare=note('e2') // 5
R4=note('=') // 6
rim=note('f3') // 7

all = join(kick, clap, openhi, closehi, snare,R4, rim)

bpm (120)
drum1=duration(16,join("1 6 3 6 (1 2 5) 6 3 6 1 4 3 6 (1 2 5) 6 3 6",all))
Lp_drum1 = Loop(drum1)

// Define individual drum sounds with specific durations
kick = note('16c2')  // Kick drum
snare = note('16d2') // Snare drum
hihat = note('16e2') // Hi-hat

// Create patterns for each drum part using notemap
kickPattern = notemap('!...!...!...!', kick)  // Kick on beats 1, 3, 5, and 7
snarePattern = notemap('.!!..!!..!!..', snare) // Snare on beats 2 and 4
hihatPattern = notemap('!!!!!!!!!!!!', hihat) // Hi-hat plays every beat

// Merge all patterns into a single drum track
drumTrack = merge(kickPattern, snarePattern, hihatPattern)

// Play the drum track in a loop
loop(drumTrack)

Here’s a video of the author demonstrating the language

Recorded Demo:

What is Alda?

Alda is a music composition programming language that offers an easier and more intuitive way to create musical scores using simple syntax. It was designed for musicians with no programming experience and programmers with no music experience. Alda provides an accessible way for composing music through code without the need for much prior experience in either.

The Creator: Dave Yarwood

Alda was created and developed by Dave Yarwood, a musician and programmer with a background in bassoon performance and music composition. Fed up with existing graphical music composition tools like Sibelius, Yarwood took matters in his own hands to create a musical programming language. Yarwood described existing graphical music composition softwares to be more like graphic design softwares than music composition environments. He wanted a lower-level, distraction-free way to compose music—something similar to the modularity and flexibility of command-line tools. The process took him 4 years, and in 2012 Alda was born.

Why Alda?

The motivation behind Alda stemmed from Yarwood’s desire to make music composition and development easier. He viewed exisitng graphical notation software as an IDE (Integrated Development Environment) for music, more often than not he would get distracted by the interface rather than focus on composition. Alternatively, Alda allows musicians to compose scores using simple text, making it easier to focus on the musical structure rather than navigating complex UI elements, memorizing hotkeys and looking for shortcuts.

By removing graphical distractions, it offers a more direct and expressive way to write music, much like writing sheet music by hand but with the benefits of digital tools and the ability to run the composition in realtime.

Influences and Design Philosophy

While developing Alda, Yarwood explored existing text-based notation systems but found none that exactly fulfilled his needs. However, several languages and frameworks influenced Alda’s design:

• ABC and LilyPond – Both are markup-based tools designed for generating sheet music, inspiring Alda’s approach to notation.
• Music Macro Language (MML) – Provided an expressive syntax for defining music programmatically.
• Clojure – Yarwood leveraged Clojure to hook into MIDI synthesizers, allowing Alda to generate sound from its text-based notation.

How Alda Works

Alda is a mix between a markup language and a functional programming language. It allows composers to write musical scores in plain text, which are then parsed and evaluated into Clojure code. This approach ensures flexibility, making it easy to compose, edit, and experiment with musical ideas in a streamlined and efficient manner.

Demo

Mini composed song

Slide Deck

Devine Lu Linvega currently lives on a sailboat, and can be found lurking in discord chat rooms hinting at possible bugs and easter eggs in his work. He also created ORCA, along with its companion programs (such as the synthesiser Pilot which we will be using ) under the design collective 100rabbits aboard Devine’s sailboat.

What is ORCA?

Orca is a visual programming environment for making music. Except, there are no words, loops or long lines of code. The IDE is simply a grid composed of placeholder ‘*’ characters. The program does not produce sound on its own, and instead produces MIDI events, OSC connections and UDP packets to communicate what sound should be played. I use Pilot, which is a synthesizer that Devines’ team created to produce my sounds. Even then, I could not send MIDI events to pilot. However, I could send them to superCollider. This approach did not work as Supercollider began picking up some immutable background noise through the same port. Hence I used UDP packets with the “;” operator to create sounds.

How does ORCA work?

The interaction of code and computer flows through “bangs”, a concept borrowed from Max/MSP and Pure Data. live programming concepts of immediate execution. These bangs differ from traditional programming languages like C which have complex blocks of code.

The bangs are maintained by frames which are discrete time steps. Each frame represents one “tick” of the sequencer’s clock (its rate is determined by the BPM). Every frame, the grid is updated and evaluated. Uppercase operators in ORCA execute automatically on every frame, ensuring a continuous, rhythmic flow of actions.

ORCAs IDE was built on inspiration from early 2000s games like Dwarf Fortress.

Operators
There are only 26 alphabetical operators. They go from A-Z and have 8 special operators. Some familiar operators to what we have seen in Tidalcycles are:
C clock(rate mod): Outputs modulo of frame.
D delay(rate mod): Bangs on modulo of frame.
U uclid(step max): Bangs on Euclidean rhythm.
: midi(ch oct note velocity*): Send a midi note.
; pitch(oct note): Send pitch byte out. (Sends this as a UDP message to the synthsizer)
Also interestingly, operators N, S, E, W, which represent the directions can be used to send bangs in their respective directions. Devine shows that this works lille sending marbles to collide with an object.

The above operators produce bangs, combined with other functions such as add and variables, we can make these bangs come in contact with events that we created. An example MIDI event is “:94g..”

The tools roots are from a misunderstanding about tidal that Devine had. ORCA tries to give an accessible way to do generative programming without a large programming background. The tool in a way gamifies the experience of making music in contrast to coding, making music. As ORCA does not compile and run in to errors, live coders experiment will not face syntax errors or compilation errors while editing the code.

However, the packaging of ORCA may seem inaccessible to some, the browser based package requires webMidi to be installed and configured and the locally run version that runs on node requires building on the terminal. Furthermore ORCA is a very “cool” tool to use in front of an audience as the interface between the computer and programmer transcends that of traditional programming languages. From a performance perspective, Orca can also connect to Unity, enabling interaction with 3D graphics. ORCA represents a paradigm shift in live coding by proving that constraints breed creativity. As Devine Lu Linvega states: “It’s for children. The documentation fits in a tweet”, yet professionals use it for everything from IDM sets to interactive installations. ORCA is both entry point and advanced tool in the ecosystem of computational art.

Below is a demo of ORCA in action.

Many ORCA users are technically proficient, employing the tool for solo experimentation with synths or DAWs, yet the platform thrives on community involvement and input. An engaged live coding community collaborates on Discord and Reddit, sharing techniques and directly interacting with creator Devine Lu Linvega, who actively participates in discussions and guides the ecosystem’s evolution through hints and open dialogue.

LiMuT is a live coding platform that combines both audio and visuals in a web browser. According to its creator, Stephen Clibbery, it was inspired by FoxDot, it aims to make creative coding more accessible by running entirely in any modern browser with no installation required. This allows users to experiment with generative music and real-time graphics seamlessly, making it a powerful tool for both live performances and creative exploration.

The platform’s strength lies in its easy setup, as it can be run directly from any modern browser at https://sdclibbery.github.io/limut/. While it supports both visuals and audio, there are limited options for integrating the two. Many of the visual tools are fixed, offering little room for customization. Despite this, LiMuT remains a powerful live coding tool that provides flexibility for performance. I decided to dive into the documentation, experimenting with and tweaking parts of the examples to better understand how each element interacts with the others.

LiMuT uses its own custom live coding language, which is primarily based on text-based patterns to generate music algorithmically. It draws some similarities from other live coding languages like TidalCycles and Sonic Pi, but its syntax and structure are unique to Limut.

The language itself is highly pattern-driven, meaning you write sequences that define musical events (like notes, rhythms, effects, etc.) and then manipulate these patterns in real-time. The language isn’t directly derived from a general-purpose programming language but instead is designed specifically for musical composition and performance.

Here’s how it stands out:

• Pattern-based syntax: You define rhythms, pitches, and effects in a highly modular, shorthand format.

• Time manipulation: Limut provides commands that adjust tempo, duration, amplitude, and other musical properties in real time.
• Easy to Navigate: The user interface is designed in a way that makes navigation easy.

Here’s a demo of me live coding using LiMuT

Cascade is a web-based live coding environment introduced by Raphaël Bastide in 2021. It transforms built-in CSS and HTML in web browsers into a tool for creating sound and visuals. Since Cascade is entirely browser-based, no additional setup or external modules are required, users simply reference the core scripts in an HTML file and/or a CSS file to get started.

How it works?

Cascade generates sound and visuals based on the shapes and positions of elements on a webpage. Each property of an element (such as width, height, and position) influences specific musical attributes. For instance, the width-to-height ratio represents the number of beats and steps, following Godfried Toussaint’s Euclidean rhythm distribution. This integration of web design with music encourages users to think about both the visual aesthetics and how they contribute to sound production. As I tried it by myself, it was quite difficult to come up with a meaningful visual along with a good sound. However, thanks to the CSS properties, the animations are interpreted in real-time allowing more dynamic visuals.

c.add('width:10vh; height:30px; background:cyan; top:80vh;')

For example, the above line allows to add a div into the body so that it has width of 10vh and height of 30px. The background is cyan which will be match with the according instrument set by Cascade. The vertical position (top: 80vh) adjusts the note pitch, making the note higher and louder.

Why Cascade?

Cascade offers a gentle learning curve for those familiar with web development, as it introduces no new language or syntax beyond standard CSS and HTML. This makes it an accessible entry point for newcomers to live coding while providing a creative playground for experienced developers. It also fosters collaboration between performers and audiences. Performers can modify, see, and listen in real-time, while audiences can watch and listen to the evolving performance.

Cascade bridges the gap between web development and live coding, making it a powerful tool for exploring sound through visual design. It allows users to combine or learn both disciplines simultaneously. Every design decision affects the resulting sound, prompting a thoughtful approach to composition and layout. This blend of sound and visual design invites users to experience the intersection of aesthetics and music in new and exciting ways.

Demo

Link (in case the preview does not work)

Citation

“Cascade.” Raphaelbastide.com, 2025, raphaelbastide.com/cascade/#cascade-pool-collab-mode. Accessed 13 Feb. 2025.

‌

About Strudel:

Strudel is a version of Tidal Cycles that was initiated by Alex McLean and Felix Roos and developed in 2022. It’s a web browser based platform (hence does not require internal, external software installation unlike Tidal Cycles) that primarily focuses on musical composition and sound synthesis and used to create algorithmic music patterns. It’s a beginner friendly platform, written in JavaScript through pattern-based programming which makes it easy to parse. This pattern-based syntax enables users to define musical elements: rhythms, melodies, effects, using simple text-based patterns. Essentially, music is described using structured symbols and sequences rather than utilizing traditional sheet music, or necessitating complex programming.

Live coding with Strudel is different from conventional performance art. It has no associations with generative art but rather places a central focus on music. This artistic performance is embodied through code projection with Strudel itself allowing for instant feedback, enabling for a seamless and fluid performance and further enhancing live coding culture. Moreover, it’s innovative as a cultural expression for one of 2 interrelated reasons. Strudel allows for democratization of music creation. By lowering the technical barriers that demarcate coding, this performance act is made more accessible to a greater range of audience that embody diverse backgrounds. Moreover, Strudel as a platform, also contributes to the ethos of live coding which accentuates transparency and shared knowledge. This is profound as it reflects the prominent cultural shift toward openness and collective growth in digital arts where code itself materializes as a means of creative exchange. Platforms like Strudel therefore promote live coding to be a more inclusive and participatory artistic practice.

Live Coding Demo and Process:

live coding demo!

Overall, I’m incredibly satisfied with the final result. What I have come to realize is the immense joy and fulfillment derived from the process of experimentation and exploration in creating an ever-evolving sonic experience! Given my stronger affinity for sound over visual elements, this journey has been particularly enjoyable. Initially, I felt overwhelmed by the unfamiliar notations, but after reviewing the workshop documentation—First Sounds, First Notes, First Effects, and Pattern Effects—I began integrating new functions to observe firsthand how the sounds would transform. This process involved considerable trial and error—duplicating and adjusting code, fine-tuning numerical values, and mix-matching sound effects, all while combining them with varying parameters. Once I established an initial piano melody, I proceeded to build upon it by layering additional musical elements: 2) drum beat, 3) main melody, 4) supporting guitar melody. The outcome surpassed my expectations, and I am genuinely pleased with how it has all come together.

Time taken – 2.5-3 hours!!!

A web-based audio-visual programming system, Tweakable prompts users to “make interactive and generative music, sound and visual art” by making them choose from a wide range of components to design their own algorithmic systems while also setting up controls that allow them to adjust how the algorithm works in real-time, hence the name “Tweakable.” According to the Wayback Machine, Tweakable.org was first active on June 6, 2002, and then was inactive from 2003 till 2020; finally, the website we currently have was a version launched on December 17, 2020 (“Wayback”).

There are 3 big components in Tweakable: Data Input/Flow, Sequencing, and Audio, with an additional option to create custom modules as well. Data Input/Flow includes control inputs like sliders and MIDI and controls how information flows in the platform. Sequencing generates and transforms musical patterns using grids, scripts, and mathematical functions, while Audio converts sequences into sound through instruments, oscillators, and automated effects (Woodward). When the user wants to create a new project, they will first choose from a pre-built library made of sequences, audio, video, effects, etc., and they will then connect those components together to create an algorithmic system. Finally, after the system has been made, they will also need to build a user interface so that their algorithm can be tweaked (“Tweakable”).

With its main goal is lowering the entry barrier for programming music or visual art for all users, Tweakable invites users with no background knowledge to not only easily create their own works but also share their projects “without worrying about missing dependencies” since it’s web-based. By being a web where users can tweak and experiment with parameters in live time, Tweakable was one of the earliest pioneering live coding platforms at the time of its creation; and not only does it encompass live coding’s key characteristic of allowing users to write and modify code in real-time to create music and visuals, it also made the algorithmic generation of art more accessible and intuitive with its visual component-based approach, thus opening up the platform to anyone ranging from a total novice to an expert (Woodward).

Finally, here’s a video of me playing around with Tweakable, and the slides are here 🙂

Works Cited

“Tweakable.” IRCAM Forum, forum.ircam.fr/projects/detail/tweakable/#project-intro-anchor. Accessed 12 Feb. 2025. 

“Wayback Machine.” Expand Web Menu, web.archive.org/. Accessed 12 Feb. 2025. 

Woodward, Julian. Tweakable – NTNU, www.ntnu.edu/documents/1282113268/1290817988/WAC2019-CameraReadySubmission-10.pdf/bf702376-a6e4-a270-6581-f80f55bbbfec?t=1575408891372. Accessed 12 Feb. 2025.