2026-10-15 - Release: Lost --- New algorithms, new DAW, some patience, much impatience. Lower the volume.

Ratio9’s standalone version is free for Apple silicon Macs running macOS 12 or later. I’m Max, its developer; version 1.2.1 is now available.

Ratio9 lets a compatible AI assistant create presets by controlling the instrument itself. It can select wavetables, shape LFOs, connect modulation, set effects and macros, audition notes, and save the patch. You can then play it and keep shaping it with the same controls.

The built-in spectrum and spectrogram give the connected assistant fresh measurements of the sound as it revises the preset. The idea is to combine parameter exploration with feedback from the resulting audio. You choose the sound-design goal and decide which results are worth keeping.

AI is optional. Connect an installed client that supports local stdio MCP, or use the synth entirely by hand. The instrument includes three wavetable oscillators, six LFOs, eight macros, two filters, a sampler and multiband effects.

The pictures show the main interface at INIT and a separate growl preset in the live spectrum/spectrogram view.

I’d be interested in what you would want to generate first: evolving textures, rhythmic modulation, or variations of a sound you already like.

The complete standalone synth is free. Optional VST3 + AU plug-ins are $79.99 USD once for two Macs. You bring your own AI account and compatible client. This is an alpha release; complex patches can cause CPU spikes or dropouts.

Download and setup: https://ratio9synth.com/download

Algorithmic composition, combined with patience, can be rewarding. Then again, now I have to see if I can be patient enough to create some reasonably decent visualization ...

2026-10-08 - Macchinario (Machinery)

Hi, Davide here.
I built a very simple block chord generator with some scale and basic shapes presets. It follows some simple rules: notes that belong to the base chord shape use its inversion which has them as the top voice; other scale degrees are harmonized with descending thirds along the scale. voices making a tritone with the melody are corrected by a scale step. notes outside the scale and the base shape are harmonized as a chromatic alteration of the nearest in-scale chord, optionally transposed.
Let me know what I can improve!

The 16th International Conference on Artificial Intelligence in Music, Sound, Art and Design (EvoMusArt 2027) is accepting paper submissions.

When: 31 March – 2 April 2027
Where: Mainz, Germany
Paper Submission deadline: 1 November 2026

EvoMUSART focuses on AI and computational approaches to creativity, covering a broad range of topics, with a particular emphasis on research exploring how AI systems generate, support, evaluate, interpret, and collaborate in creative processes.

Accepted papers will be presented at the conference and published in a dedicated LNCS volume.

More information/submission details: https://www.evostar.org/2027/evomusart/

If you are working at the intersection of AI and creative practice, this may be relevant to your research. Please share with others who might be interested.

Hi folks,

Back in March I posted here about Subsequence, the algorithmic MIDI sequencer I've been writing in Python. A lot has changed since, so here's an update, along with a much better place to start: it now has proper documentation, including a full guide, at https://subsystem.co/subsequence

What it does

Subsequence plays algorithmic compositions that keep evolving: parts that develop over time, answer each other and move through the sections of a piece, over chord progressions it can choose as it goes. It drives your synths, drum machines, Eurorack or DAW over MIDI.

• Evolving, algorithmic music. Parts remember what they've played, know the chord and the section they're in, and can respond to each other, so the music develops rather than loops. Harmony can be included from weighted chord graphs in twelve styles, from functional major to chromatic mediants and whole-tone, and melodies can follow Narmour's implication-realisation model, where big leaps tend to turn back and small steps carry on.
• Live coding, at the terminal and in files. Change a piece while it plays, from a Python prompt connected to it, or by saving its file, which is heard from the next bar without the music stopping. Keys on your keyboard can fire fills and jump between sections as you perform.
• An abundance of algorithms. Nineteen algorithmic generators and more than fifty sequence utilities: Euclidean and Bresenham rhythms, Markov chains, L-systems, one- and two-dimensional cellular automata, the Lorenz attractor, Gray-Scott reaction-diffusion, Perlin and pink noise, logistic-map chaos, Recamán, Thue-Morse, de Bruijn, Fibonacci and golden-ratio rhythms, self-avoiding walks and Xenakis sieves, plus swing, grooves, ratchets and other transforms to reshape what they place.
• Connected to my other apps. Subsample, a sampler that turns a microphone or any recording into a playable instrument, and Substation, a radio scanner, can each tell a running composition what they've just heard, and Superconductor (in very early stages) puts a composition's controls on a touchscreen. More on those below.

Under the hood, a composition is plain Python: one function per part, which Subsequence runs again before every cycle, handing it the chord that's sounding, the section it's in, how many times it has played and anything the other parts have shared. Give a piece a seed and every random choice in it repeats exactly, so anything that surprises you can be played again. It makes no sound of its own: it's pure MIDI.

What's new since March

• More algorithms. L-systems, the Lorenz attractor, reaction-diffusion, Recamán, Thue-Morse and de Bruijn sequences, Fibonacci and golden-ratio rhythms, self-avoiding walks, 2D cellular automata and Xenakis sieves are all new, along with Toussaint's evenness, off-beatness and syncopation measures, so one part can respond to how syncopated another is playing.
• Musical structure. Motifs written in scale degrees, which can be varied and developed, phrases including the classical sentence and period (question, then answer), cadences, Roman-numeral progressions and harmonic rhythm. An energy dial arranges a piece section by section, and fills and mutes can mark the boundaries automatically.
• Microtonal tuning. Any equal temperament, a list of ratios or cents, or a Scala .scl file, played through per-note pitch bend, so no MPE is needed.
• Live coding by saving the file, and one-shots triggered live that land on the next beat or bar.
• More ways to connect. Ableton Link, a knob and a held chord from a MIDI keyboard feeding a part, one part played on several instruments at once, and MIDI files that keep each device on its own track, from a render or a live take.
• Tighter timing. Pulse jitter is typically about 1 µs on Linux, no pulse lands more than 0.1 ms out at any tempo from 60 to 200 BPM, and there's no long-term drift.

The documentation

The old API page has gone. In its place, https://subsystem.co/subsequence has:

• A guide that teaches Subsequence by building one piece of music: from a first drum beat, through ghost notes, a Euclidean snare, swing, a bass line, chords that move, a melody that remembers, motifs, form, parts that listen to each other, and filter sweeps and slides, to a lead line driven by a day of London weather. Then microtonal tuning, performing, live coding, playing with other gear, and capturing a take as a MIDI file. Every example in it is run against the current release whenever the site is built.
• An API reference and a cheat sheet, both generated from the code, so they can't drift away from it.

The apps around it

Subsequence is one of a small family of tools I've been building, all documented at https://subsystem.co:

• Subsample cuts separate sounds out of a live input or a recording, sorts them by how they sound, and plays them as an instrument from MIDI. Subsequence can play it, the two can share one file of sound names, and with OSC switched on, Subsample can tell a composition what it has just captured.
• Substation is an SDR band scanner that detects, demodulates and records radio transmissions. It can tell a composition over OSC what it has just heard, and Subsample can import its recordings as sounds to play.
• Superconductor is a new control surface for Subsequence: a page in the browser that draws a composition's controls (step grids, note grids, stacks of generators and transforms) so you can change it by touch, or with a mouse, while it plays. It's at a very early stage, so expect rough edges and plenty of change.

Who it's for

Musicians who like generative and algorithmic music, don't mind writing a little Python, and want to drive the gear they already have. The guide starts from installing it and hearing a first note, on macOS, Windows or Linux. It's open source (AGPL-3.0): pip install subsequence, on Python 3.10 or later.

I'd love to hear what you make of it (and with it), and what's missing.

• Documentation and guide: https://subsystem.co/subsequence
• Code: https://github.com/simonholliday/subsequence

Thanks :)

Si.

I built a Bach-style counterpoint engine and used it for two pieces named QVINTVS.

QVINTVS I keeps the harmony/form fixed and only rescales the drum grid 4x — the rest of the ensemble targets a Daft Punk / Fleetwood Mac sound. https://youtu.be/H0UbjMbsAqM

QVINTVS II is the more "algorithmic" one: same 44-bar plan in D minor, but each section swaps exactly one function's timbre/reference-artist — piano (Bach) -> ocarina (Wes Montgomery), guitar (Nile Rodgers) -> alto sax (Bach prelude), finger bass (Jamerson) -> finger bass (Bootsy) — while channel, register and function stay fixed. Drums (Tony Allen, slowed 4x) sit outside the rotation. https://youtu.be/0glMiNZpXUU

Video is generated pixel art (Greek temple, CRT screen, real moon phases) rendered in sync with the piece.

https://scratch.mit.edu/projects/1383879699/

here's the trick behind how i fit 8 music tracks in my js13k game SP13KTRA. 🌈🚀

every song is defined by a single number. the seeded random generator makes 26 dice rolls per track: tempo, key, scale, chords, groove, drum kit, bass and lead sounds, melody patterns, when each part comes in, and a few more.

each song is a 128 beat loop split into sections. parts come in one by one, a resonant filter sweeps open every phrase, then there's a breakdown and a drop.

notes use one of 4 predefined scales so nothing clashes. the melody climbs, falls, leaps or rocks through the scale, and the chords shift every 4 bars. there's no note data, it's all math on the beat count.

there are 6 ZzFX instruments plus echo and sidechain. the whole loop gets baked into one buffer when the level loads.

the music itself is all rules and seeds, not AI. i did use AI to help build this bench so i could listen through seeds and pick a good one for each level.

play it free in your browser and hear all the music. i designed it to be kind of like a music album in addition to a game.

https://js13kgames.com/2026/games/sp13ktra

The music bench tool is also available to check out on GitHub.

https://killedbyapixel.github.io/SP13KTRA/tools/music.html

A very simple and light track, inspired by a "B" Fantasy movie that I recently watched. Algorithmic composition, a few human additions here and there which make, overall, for a better and airy sound. A good chunk of the software used in the assembly is custom made. One of these days, I may even figure out if is worth packaging for sharing.

I made a Mathematician's Groovebox that makes music, videos and games from numbers equations and fractals (as well as videos and recordings)

https://github.com/wittymoniker/groove-box/
youtube: wittymoniker
github: wittymoniker/groove-box (single point of entry run and build scripts, crossplatform)

It relies on Euclidean phaselocking of numeric data followed by randomized stochastic improvisation. Within bounds of net phase angle relativistic indeterminism the results are deterministic always to the degree of point-to-point phase angle -rough translation of audio signal. SO its a fractal of every way to turn a number or graph into music.

Hello everyone!

Here is a small showcase of the Grainscape engine on the SkunkAudio mobile DAW Android app.

It's a Granular Synthesis engine, playing some notes in arpeggiator and adding some fx live.

Thank you for your time!

P.S. For anyone interested, the app atm is on a -50% sale on Google Play Store.

Hello everyone, I am upgrading the DOOM engine on my app, which is actually a noise and drone generator.

This is a small showcase playing with the touchpad and tweaking some oscillator knobs.

I would appreciate a small feedback from this video on how it is displayed and how it sounds. CPU not being stressed, stays at around 10% on a mid phone.

Thank you for your time.

P.S. for anyone interested, the app will be on a -50% sale from tomorrow 04/09/2026 until 17/09/2026.

Hello everyone, I'm no pro musician and no pro coder, but I made an attempt at creating a web app that records your microphone and creates a song from it.

Just record 30, 40 seconds or more of your voice and some random sounds — the algorithm will cut the sounds up and arrange them into rhythm. Pick a genre and generate.

The dream is to create a free app that does it well. Once it's done I'll make a plugin for FL Studio.

Here is the web app, ready to use:

https://marcellomassardo-collab.github.io/mc-parrot/

Here is the GitHub repo, with the APK available to download and full documentation:

https://github.com/marcellomassardo-collab/mc-parrot

Comments are very welcome!

It's free, but development is a bitch — consider donating if you like the project.

(This is not AI!

The app does not collect any of your data)

Been working on this for the last few months and finally finished it.

Most of the music isn’t sequenced in the usual way. I built a bunch of rules around probability, timing and different states, then let the system move through them on its own. The visuals and lighting are tied into the same processes rather than being added afterwards.

It ended up somewhere between composition and just setting up the conditions for things to happen.

Would be interested to know how people here think about that line between composing something and designing a system that composes itself.

AI writing code for the Chuck language I started experimenting and got some pretty good results. Would anyone like to try out my programs?

song i made today with my very hands!

Hi, I built this web app for exploring the almost infinite melodic/harmonic possibilities offered by Nicolas Slonimsky's Thesaurus, any feedback or suggestion is welcome!
I used AI for the user interface but the melody/harmony logic is carefully written by hand to match the content of this foundational work.

CARD/OS is a launcher that has built in apps and a lightweight SDK so you can built your own cards in javascript and lua.

In this demo its showing off musical apps. Wait for it

The launcher has a dock which enabled widgets, we have a tempo widget and a mixer accessible from any app.

Running here are jusg a few of the musical apps - which all sync together.

SYNTH

Pocket Studio (similar to a pocket operator)

LOOM (programatic control over synths, drums, randomness, effects etc)

All apps can be used on their own or synced with other built in apps.

The launcher isnt yet released but it also contains a pico8 cart player, ebook/pdf reader, iptv, radio and more.

Hi everyone,

I’ve been experimenting with a method for generating new musical structures from a single notation-based MIDI file.

The basic idea is:

1. Split a MIDI file into temporally connected musical components.
2. Describe those components using pitch, rhythm, velocity, register, density, and timing features.
3. Build a similarity kernel and embed the components into a lower-dimensional space.
4. Connect the embedded components with a Bézier path.
5. Use a normalized sequence in the range [0,1] to choose positions on that path.
6. Map each selected point back to a complete MIDI component.

The sequence does not directly choose a note or chord. It chooses a position on the Bézier trajectory, and the nearest musical component is reconstructed from there.

I tested several control sequences:

• cosine
• Weierstrass
• ruler function — OEIS A001511
• paperfolding sequence — OEIS A014577
• countdown fractal — OEIS A122196
• Kimberling/Wythoff fractal — OEIS A003603
• Kimberling signature sequence — OEIS A022328
• Kimberling insertion sequence — OEIS A194959

I also added a flexible kernel parameter that controls the number of connected components. Fewer components preserve longer recognizable phrases, while more components create more fragmented and experimental results.

The reconstruction preserves complete note groups rather than generating isolated notes. It can also preserve local tempo changes from the source MIDI.

The repository contains:

• Python implementation
• command-line tools
• LilyPond examples
• notation-based MIDI examples
• mathematical documentation
• an English technical PDF
• tests and configuration examples
• notes intended to help both humans and AI systems reimplement the method

Repository:

https://github.com/githubuser1983/algorithmic_music_starter_kit

I’m especially interested in feedback from people working with algorithmic composition, MIDI processing, generative music, sonification, kernel methods, or interactive installations.

Possible applications I’m exploring include:

• structural MIDI remixing
• adaptive game music
• data sonification
• interactive installations controlled by phones or sensors
• educational tools for musical form
• generating reproducible training variations for music-AI systems

This is still experimental. It is better at reorganizing the musical vocabulary of an existing piece than at inventing completely new themes.

I’d be very interested to hear:

• Does the mathematical model make sense?
• Are the component and reconstruction choices musically reasonable?
• Which other deterministic or fractal sequences would be worth testing?
• What would make the repository easier to reproduce or extend?